Cách nhanh nhất để gửi 100.000 yêu cầu HTTP trong Python là gì?

Tôi đang mở một tệp có 100.000 URL. Tôi cần gửi yêu cầu HTTP đến từng URL và in mã trạng thái. Tôi đang sử dụng Python 2.6 và cho đến nay đã xem xét nhiều cách khó hiểu Python thực hiện xâu chuỗi / đồng thời. Tôi thậm chí đã xem thư viện đồng quy python , nhưng không thể tìm ra cách viết chương trình này một cách chính xác. Có ai gặp phải một vấn đề tương tự? Tôi đoán nói chung tôi cần biết cách thực hiện hàng ngàn tác vụ trong Python nhanh nhất có thể - tôi cho rằng điều đó có nghĩa là 'đồng thời'.

Giải pháp xoắn:

from urlparse import urlparse
from threading import Thread
import httplib, sys
from Queue import Queue

concurrent = 200

def doWork():
    while True:
        url = q.get()
        status, url = getStatus(url)
        doSomethingWithResult(status, url)
        q.task_done()

def getStatus(ourl):
    try:
        url = urlparse(ourl)
        conn = httplib.HTTPConnection(url.netloc)   
        conn.request("HEAD", url.path)
        res = conn.getresponse()
        return res.status, ourl
    except:
        return "error", ourl

def doSomethingWithResult(status, url):
    print status, url

q = Queue(concurrent * 2)
for i in range(concurrent):
    t = Thread(target=doWork)
    t.daemon = True
    t.start()
try:
    for url in open('urllist.txt'):
        q.put(url.strip())
    q.join()
except KeyboardInterrupt:
    sys.exit(1)

Cái này nhanh hơn một chút so với giải pháp xoắn và sử dụng ít CPU hơn.

Một giải pháp sử dụng thư viện mạng không đồng bộ Tornado

from tornado import ioloop, httpclient

i = 0

def handle_request(response):
    print(response.code)
    global i
    i -= 1
    if i == 0:
        ioloop.IOLoop.instance().stop()

http_client = httpclient.AsyncHTTPClient()
for url in open('urls.txt'):
    i += 1
    http_client.fetch(url.strip(), handle_request, method='HEAD')
ioloop.IOLoop.instance().start()

Mọi thứ đã thay đổi khá nhiều kể từ năm 2010 khi điều này được đăng và tôi chưa thử tất cả các câu trả lời khác nhưng tôi đã thử một vài câu và tôi thấy điều này hoạt động tốt nhất với tôi khi sử dụng python3.6.

Tôi đã có thể tìm nạp khoảng 150 tên miền duy nhất mỗi giây chạy trên AWS.

import pandas as pd
import concurrent.futures
import requests
import time

out = []
CONNECTIONS = 100
TIMEOUT = 5

tlds = open('../data/sample_1k.txt').read().splitlines()
urls = ['http://{}'.format(x) for x in tlds[1:]]

def load_url(url, timeout):
    ans = requests.head(url, timeout=timeout)
    return ans.status_code

with concurrent.futures.ThreadPoolExecutor(max_workers=CONNECTIONS) as executor:
    future_to_url = (executor.submit(load_url, url, TIMEOUT) for url in urls)
    time1 = time.time()
    for future in concurrent.futures.as_completed(future_to_url):
        try:
            data = future.result()
        except Exception as exc:
            data = str(type(exc))
        finally:
            out.append(data)

            print(str(len(out)),end="\r")

    time2 = time.time()

print(f'Took {time2-time1:.2f} s')
print(pd.Series(out).value_counts())

Chủ đề hoàn toàn không phải là câu trả lời ở đây. Họ sẽ cung cấp cả tắc nghẽn quy trình và nhân, cũng như giới hạn thông lượng không được chấp nhận nếu mục tiêu chung là "cách nhanh nhất".

Một chút twistedvà HTTPkhách hàng không đồng bộ của nó sẽ cho bạn kết quả tốt hơn nhiều.

Tôi biết đây là một câu hỏi cũ, nhưng trong Python 3.7 bạn có thể làm điều này bằng cách sử dụng asynciovà aiohttp.

import asyncio
import aiohttp
from aiohttp import ClientSession, ClientConnectorError

async def fetch_html(url: str, session: ClientSession, **kwargs) -> tuple:
    try:
        resp = await session.request(method="GET", url=url, **kwargs)
    except ClientConnectorError:
        return (url, 404)
    return (url, resp.status)

async def make_requests(urls: set, **kwargs) -> None:
    async with ClientSession() as session:
        tasks = []
        for url in urls:
            tasks.append(
                fetch_html(url=url, session=session, **kwargs)
            )
        results = await asyncio.gather(*tasks)

    for result in results:
        print(f'{result[1]} - {str(result[0])}')

if __name__ == "__main__":
    import pathlib
    import sys

    assert sys.version_info >= (3, 7), "Script requires Python 3.7+."
    here = pathlib.Path(__file__).parent

    with open(here.joinpath("urls.txt")) as infile:
        urls = set(map(str.strip, infile))

    asyncio.run(make_requests(urls=urls))

Bạn có thể đọc thêm về nó và xem một ví dụ ở đây .

Sử dụng grequests , đó là sự kết hợp của các yêu cầu + mô đun Gevent.

GRequests cho phép bạn sử dụng các Yêu cầu với Gevent để thực hiện các Yêu cầu HTTP không đồng bộ một cách dễ dàng.

Cách sử dụng rất đơn giản:

import grequests

urls = [
   'http://www.heroku.com',
   'http://tablib.org',
   'http://httpbin.org',
   'http://python-requests.org',
   'http://kennethreitz.com'
]

Tạo một tập hợp các Yêu cầu chưa gửi:

>>> rs = (grequests.get(u) for u in urls)

Gửi tất cả chúng cùng một lúc:

>>> grequests.map(rs)
[<Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>, <Response [200]>]

Một cách tiếp cận tốt để giải quyết vấn đề này là trước tiên hãy viết mã cần thiết để có được một kết quả, sau đó kết hợp mã luồng để song song hóa ứng dụng.

Trong một thế giới hoàn hảo, điều này đơn giản có nghĩa là đồng thời bắt đầu 100.000 luồng kết quả đưa ra kết quả của chúng vào một từ điển hoặc danh sách để xử lý sau này, nhưng trong thực tế, bạn bị giới hạn về số lượng yêu cầu HTTP song song bạn có thể đưa ra theo cách này. Tại địa phương, bạn có giới hạn về số lượng ổ cắm bạn có thể mở đồng thời, bao nhiêu luồng thực thi mà trình thông dịch Python của bạn sẽ cho phép. Từ xa, bạn có thể bị giới hạn số lượng kết nối đồng thời nếu tất cả các yêu cầu chống lại một máy chủ hoặc nhiều máy chủ. Những hạn chế này có thể sẽ khiến bạn phải viết tập lệnh theo cách chỉ thăm dò một phần nhỏ các URL bất kỳ lúc nào (100, như một poster khác được đề cập, có thể là kích thước nhóm chủ đề khá, mặc dù bạn có thể thấy rằng bạn có thể triển khai thành công nhiều hơn nữa).

Bạn có thể làm theo mẫu thiết kế này để giải quyết vấn đề trên:

1. Bắt đầu một luồng khởi chạy các luồng yêu cầu mới cho đến khi số luồng hiện đang chạy (bạn có thể theo dõi chúng thông qua threading.active_count () hoặc bằng cách đẩy các đối tượng luồng vào cấu trúc dữ liệu) là> = số lượng yêu cầu đồng thời tối đa của bạn (giả sử 100) , sau đó ngủ trong một thời gian ngắn. Chuỗi này sẽ chấm dứt khi không còn URL nào để xử lý. Do đó, chuỗi sẽ tiếp tục thức dậy, khởi chạy các luồng mới và ngủ cho đến khi bạn kết thúc.
2. Có các luồng yêu cầu lưu trữ kết quả của chúng trong một số cấu trúc dữ liệu để lấy và xuất sau này. Nếu cấu trúc bạn đang lưu trữ kết quả là một listhoặc dicttrong CPython, bạn có thể nối hoặc chèn các mục duy nhất từ ​​các luồng của mình một cách an toàn mà không cần khóa , nhưng nếu bạn ghi vào tệp hoặc yêu cầu tương tác dữ liệu chéo phức tạp hơn, bạn nên sử dụng khóa loại trừ lẫn nhau để bảo vệ nhà nước này khỏi tham nhũng .

Tôi sẽ đề nghị bạn sử dụng các mô-đun luồng . Bạn có thể sử dụng nó để khởi chạy và theo dõi các chủ đề đang chạy. Hỗ trợ luồng của Python hoàn toàn trống rỗng, nhưng mô tả về vấn đề của bạn cho thấy rằng nó hoàn toàn đủ cho nhu cầu của bạn.

Cuối cùng, nếu bạn muốn xem một ứng dụng đơn giản xinh đẹp của một ứng dụng mạng song song viết bằng Python, hãy kiểm tra ssh.py . Đó là một thư viện nhỏ sử dụng luồng Python để song song nhiều kết nối SSH. Thiết kế đủ gần với yêu cầu của bạn mà bạn có thể thấy nó là một tài nguyên tốt.

Nếu bạn đang tìm kiếm để có được hiệu suất tốt nhất có thể, bạn có thể muốn xem xét sử dụng I / O không đồng bộ thay vì các luồng. Chi phí hoạt động liên kết với hàng ngàn luồng hệ điều hành là không tầm thường và việc chuyển đổi ngữ cảnh trong trình thông dịch Python còn bổ sung nhiều hơn nữa trên đầu trang. Việc phân luồng chắc chắn sẽ hoàn thành công việc nhưng tôi nghi ngờ rằng một tuyến không đồng bộ sẽ cung cấp hiệu suất tổng thể tốt hơn.

Cụ thể, tôi đề xuất ứng dụng web async trong thư viện Twisted ( http://www.twistedmatrix.com ). Nó có một đường cong học tập dốc được thừa nhận nhưng nó khá dễ sử dụng một khi bạn nắm được cách tốt trong phong cách lập trình không đồng bộ của Twisted.

API ứng dụng khách không đồng bộ của HowTo trên Twisted có sẵn tại:

http://twistedmatrix.com/document/cản/web/howto/client.html

Một giải pháp:

from twisted.internet import reactor, threads
from urlparse import urlparse
import httplib
import itertools


concurrent = 200
finished=itertools.count(1)
reactor.suggestThreadPoolSize(concurrent)

def getStatus(ourl):
    url = urlparse(ourl)
    conn = httplib.HTTPConnection(url.netloc)   
    conn.request("HEAD", url.path)
    res = conn.getresponse()
    return res.status

def processResponse(response,url):
    print response, url
    processedOne()

def processError(error,url):
    print "error", url#, error
    processedOne()

def processedOne():
    if finished.next()==added:
        reactor.stop()

def addTask(url):
    req = threads.deferToThread(getStatus, url)
    req.addCallback(processResponse, url)
    req.addErrback(processError, url)   

added=0
for url in open('urllist.txt'):
    added+=1
    addTask(url.strip())

try:
    reactor.run()
except KeyboardInterrupt:
    reactor.stop()

Thời gian thử nghiệm:

[kalmi@ubi1:~] wc -l urllist.txt
10000 urllist.txt
[kalmi@ubi1:~] time python f.py > /dev/null 

real    1m10.682s
user    0m16.020s
sys 0m10.330s
[kalmi@ubi1:~] head -n 6 urllist.txt
http://www.google.com
http://www.bix.hu
http://www.godaddy.com
http://www.google.com
http://www.bix.hu
http://www.godaddy.com
[kalmi@ubi1:~] python f.py | head -n 6
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu
200 http://www.bix.hu

Thời gian

bix.hu is ~10 ms away from me
godaddy.com: ~170 ms
google.com: ~30 ms

Sử dụng một nhóm luồng là một lựa chọn tốt, và sẽ làm cho điều này khá dễ dàng. Thật không may, python không có một thư viện tiêu chuẩn giúp cho các nhóm luồng cực kỳ dễ dàng. Nhưng đây là một thư viện phong nha sẽ giúp bạn bắt đầu: http://www.chrisarndt.de/projects/threadpool/

Mã ví dụ từ trang web của họ:

pool = ThreadPool(poolsize)
requests = makeRequests(some_callable, list_of_args, callback)
[pool.putRequest(req) for req in requests]
pool.wait()

Hi vọng điêu nay co ich.

Tạo epollđối tượng,
mở nhiều socket TCP của máy khách,
điều chỉnh bộ đệm gửi của chúng nhiều hơn một chút so với tiêu đề yêu cầu,
gửi tiêu đề yêu cầu - cần ngay lập tức, chỉ cần đặt vào bộ đệm, đăng ký socket trong epollđối tượng,
thực hiện .polltrên epollobect,
đọc 3 đầu tiên byte từ mỗi socket từ .poll,
ghi chúng sys.stdouttheo sau \n(không tuôn ra), đóng socket của máy khách.

Giới hạn số lượng ổ cắm được mở đồng thời - xử lý lỗi khi ổ cắm được tạo. Tạo một ổ cắm mới chỉ khi một cái khác được đóng lại.
Điều chỉnh giới hạn hệ điều hành.
Hãy thử chuyển sang một vài (không nhiều) quy trình: điều này có thể giúp sử dụng CPU hiệu quả hơn một chút.

Đối với trường hợp của bạn, phân luồng có thể sẽ thực hiện thủ thuật vì có lẽ bạn sẽ dành nhiều thời gian nhất để chờ phản hồi. Có các mô-đun hữu ích như Hàng đợi trong thư viện chuẩn có thể giúp ích.

Tôi đã làm một điều tương tự với việc tải xuống các tệp song song trước đó và nó đủ tốt cho tôi, nhưng nó không ở quy mô mà bạn đang nói đến.

Nếu tác vụ của bạn bị ràng buộc nhiều CPU hơn, bạn có thể muốn xem xét mô-đun đa xử lý , điều này sẽ cho phép bạn sử dụng nhiều CPU / lõi / luồng hơn (nhiều quá trình sẽ không chặn nhau vì khóa là trên mỗi tiến trình)

Cân nhắc sử dụng Cối xay gió , mặc dù Cối xay gió có thể không làm được nhiều chủ đề.

Bạn có thể làm điều đó với một tập lệnh Python cuộn bằng tay trên 5 máy, mỗi máy kết nối ra ngoài bằng các cổng 40000-60000, mở 100.000 kết nối cổng.

Ngoài ra, có thể giúp thực hiện một thử nghiệm mẫu với ứng dụng QA có luồng độc đáo như OpenSTA để có ý tưởng về mỗi máy chủ có thể xử lý được bao nhiêu.

Ngoài ra, hãy thử xem xét chỉ sử dụng Perl đơn giản với lớp LWP :: ConnCache. Có thể bạn sẽ nhận được nhiều hiệu suất hơn (nhiều kết nối hơn) theo cách đó.

Máy khách web async xoắn này đi khá nhanh.

#!/usr/bin/python2.7

from twisted.internet import reactor
from twisted.internet.defer import Deferred, DeferredList, DeferredLock
from twisted.internet.defer import inlineCallbacks
from twisted.web.client import Agent, HTTPConnectionPool
from twisted.web.http_headers import Headers
from pprint import pprint
from collections import defaultdict
from urlparse import urlparse
from random import randrange
import fileinput

pool = HTTPConnectionPool(reactor)
pool.maxPersistentPerHost = 16
agent = Agent(reactor, pool)
locks = defaultdict(DeferredLock)
codes = {}

def getLock(url, simultaneous = 1):
    return locks[urlparse(url).netloc, randrange(simultaneous)]

@inlineCallbacks
def getMapping(url):
    # Limit ourselves to 4 simultaneous connections per host
    # Tweak this number, but it should be no larger than pool.maxPersistentPerHost 
    lock = getLock(url,4)
    yield lock.acquire()
    try:
        resp = yield agent.request('HEAD', url)
        codes[url] = resp.code
    except Exception as e:
        codes[url] = str(e)
    finally:
        lock.release()


dl = DeferredList(getMapping(url.strip()) for url in fileinput.input())
dl.addCallback(lambda _: reactor.stop())

reactor.run()
pprint(codes)

Tôi thấy rằng sử dụng tornadogói là cách nhanh nhất và đơn giản nhất để đạt được điều này:

from tornado import ioloop, httpclient, gen


def main(urls):
    """
    Asynchronously download the HTML contents of a list of URLs.
    :param urls: A list of URLs to download.
    :return: List of response objects, one for each URL.
    """

    @gen.coroutine
    def fetch_and_handle():
        httpclient.AsyncHTTPClient.configure(None, defaults=dict(user_agent='MyUserAgent'))
        http_client = httpclient.AsyncHTTPClient()
        waiter = gen.WaitIterator(*[http_client.fetch(url, raise_error=False, method='HEAD')
                                    for url in urls])
        results = []
        # Wait for the jobs to complete
        while not waiter.done():
            try:
                response = yield waiter.next()
            except httpclient.HTTPError as e:
                print(f'Non-200 HTTP response returned: {e}')
                continue
            except Exception as e:
                print(f'An unexpected error occurred querying: {e}')
                continue
            else:
                print(f'URL \'{response.request.url}\' has status code <{response.code}>')
                results.append(response)
        return results

    loop = ioloop.IOLoop.current()
    web_pages = loop.run_sync(fetch_and_handle)

    return web_pages

my_urls = ['url1.com', 'url2.com', 'url100000.com']
responses = main(my_urls)
print(responses[0])

Cách dễ nhất là sử dụng thư viện luồng tích hợp của Python. Chúng không phải là "thực" / chuỗi nhân Chúng có vấn đề (như tuần tự hóa), nhưng đủ tốt. Bạn muốn có một hàng đợi & chuỗi chủ đề. Một lựa chọn là ở đây , nhưng nó là tầm thường để viết của riêng bạn. Bạn không thể song song tất cả 100.000 cuộc gọi, nhưng bạn có thể loại bỏ 100 (hoặc hơn) cuộc gọi đó cùng một lúc.