Apa cara tercepat untuk mengirim 100.000 permintaan HTTP dengan Python?

Saya membuka file yang memiliki 100.000 URL. Saya perlu mengirim permintaan HTTP ke setiap URL dan mencetak kode status. Saya menggunakan Python 2.6, dan sejauh ini melihat banyak cara membingungkan Python mengimplementasikan threading / concurrency. Saya bahkan telah melihat pustaka persetujuan python , tetapi tidak tahu bagaimana menulis program ini dengan benar. Adakah yang mengalami masalah serupa? Saya kira secara umum saya perlu tahu bagaimana melakukan ribuan tugas dengan Python secepat mungkin - saya kira itu berarti 'bersamaan'.

Solusi twistedless:

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)

Yang ini sedikit lebih cepat daripada solusi memutar dan menggunakan lebih sedikit CPU.

Solusi menggunakan tornado pustaka jaringan tidak sinkron

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()

Hal-hal telah berubah sedikit sejak 2010 ketika ini diposting dan saya belum mencoba semua jawaban lain tetapi saya telah mencoba beberapa, dan saya menemukan ini berfungsi terbaik untuk saya menggunakan python3.6.

Saya dapat mengambil sekitar ~ 150 domain unik per detik yang berjalan di 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())

Utas sama sekali bukan jawaban di sini. Mereka akan memberikan bottlenecks proses dan kernel, serta batas throughput yang tidak dapat diterima jika tujuan keseluruhan adalah "cara tercepat".

Sedikit twisteddan HTTPklien asinkronnya akan memberi Anda hasil yang jauh lebih baik.

Saya tahu ini adalah pertanyaan lama, tetapi dengan Python 3.7 Anda bisa melakukan ini menggunakan asynciodan 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))

Anda dapat membaca lebih lanjut tentang hal ini dan melihat contohnya di sini .

Gunakan grequests , ini kombinasi dari permintaan + modul Gevent.

GRequests memungkinkan Anda menggunakan Permintaan dengan Gevent untuk membuat Permintaan HTTP asinkron dengan mudah.

Penggunaannya sederhana:

import grequests

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

Buat satu set Permintaan yang belum terkirim:

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

Kirim semuanya sekaligus:

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

Pendekatan yang baik untuk menyelesaikan masalah ini adalah dengan terlebih dahulu menulis kode yang diperlukan untuk mendapatkan satu hasil, kemudian memasukkan kode threading untuk memparalelkan aplikasi.

Dalam dunia yang sempurna ini berarti secara simultan memulai 100.000 utas yang menampilkan hasilnya ke kamus atau daftar untuk diproses nanti, tetapi dalam praktiknya Anda terbatas pada berapa banyak permintaan HTTP paralel yang dapat Anda terbitkan dengan cara ini. Secara lokal, Anda memiliki batasan dalam berapa banyak soket yang dapat Anda buka secara bersamaan, berapa banyak utas eksekusi yang diizinkan oleh penerjemah Python Anda. Secara jarak jauh, Anda mungkin terbatas dalam jumlah koneksi simultan jika semua permintaan bertentangan dengan satu server, atau banyak. Batasan-batasan ini mungkin mengharuskan Anda menulis skrip sedemikian rupa sehingga hanya menyurvei sebagian kecil dari URL pada suatu waktu (100, seperti poster lain yang disebutkan, mungkin merupakan ukuran kumpulan thread yang layak, meskipun Anda mungkin menemukan bahwa Anda dapat berhasil menyebarkan lebih banyak).

Anda dapat mengikuti pola desain ini untuk menyelesaikan masalah di atas:

1. Mulai utas yang meluncurkan utas permintaan baru hingga jumlah utas yang saat ini berjalan (Anda dapat melacaknya melalui threading.active_count () atau dengan mendorong objek utas ke dalam struktur data) adalah> = jumlah maksimum permintaan simultan Anda (katakan 100) , lalu tidur sebentar. Utas ini harus berakhir ketika tidak ada lagi URL untuk diproses. Dengan demikian, utas akan terus bangun, meluncurkan utas baru, dan tidur sampai Anda selesai.
2. Mintalah utas permintaan menyimpan hasilnya dalam beberapa struktur data untuk pengambilan dan keluaran nanti. Jika struktur tempat Anda menyimpan hasilnya adalah listatau dictdalam CPython, Anda dapat dengan aman menambahkan atau memasukkan item unik dari utas Anda tanpa kunci , tetapi jika Anda menulis ke file atau memerlukan interaksi data cross-thread yang lebih kompleks, Anda harus menggunakan saling pengecualian mengunci untuk melindungi negara ini dari korupsi .

Saya sarankan Anda menggunakan modul threading . Anda dapat menggunakannya untuk meluncurkan dan melacak utas yang sedang berjalan. Dukungan threading Python kosong, tetapi deskripsi masalah Anda menunjukkan bahwa itu sepenuhnya cukup untuk kebutuhan Anda.

Akhirnya, jika Anda ingin melihat aplikasi langsung yang cukup dari aplikasi jaringan paralel ditulis dengan Python, memeriksa ssh.py . Ini adalah perpustakaan kecil yang menggunakan threading Python untuk memparalelkan banyak koneksi SSH. Desainnya cukup dekat dengan kebutuhan Anda sehingga Anda mungkin menganggapnya sebagai sumber yang bagus.

Jika Anda mencari untuk mendapatkan kinerja terbaik, Anda mungkin ingin mempertimbangkan untuk menggunakan Asynchronous I / O daripada utas. Overhead yang terkait dengan ribuan utas OS adalah non-sepele dan konteks beralih dalam juru bahasa Python menambahkan lebih banyak di atasnya. Threading pasti akan menyelesaikan pekerjaan tetapi saya menduga bahwa rute yang tidak sinkron akan memberikan kinerja keseluruhan yang lebih baik.

Secara khusus, saya sarankan klien web async di perpustakaan Twisted ( http://www.twistedmatrix.com ). Ini memiliki kurva belajar yang jelas curam tetapi cukup mudah digunakan setelah Anda mendapatkan pegangan yang baik pada gaya pemrograman asinkron Twisted.

API klien web asinkron Twisted's HowTo tersedia di:

http://twistedmatrix.com/documents/current/web/howto/client.html

Sebuah solusi:

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()

Waktu tes:

[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

Pingtime:

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

Menggunakan thread pool adalah pilihan yang baik, dan akan membuat ini cukup mudah. Sayangnya, python tidak memiliki pustaka standar yang membuat thread thread sangat mudah. Tapi di sini ada perpustakaan yang layak yang harus Anda mulai: http://www.chrisarndt.de/projects/threadpool/

Contoh kode dari situs mereka:

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

Semoga ini membantu.

Buat epollobjek,
terbuka banyak soket klien TCP,
menyesuaikan buffer kirim mereka untuk menjadi sedikit lebih dari header permintaan,
mengirim header permintaan - itu harus segera, hanya menempatkan ke dalam buffer, daftar soket di epollobjek,
lakukan .pollpada epollobect,
baca pertama 3 byte dari setiap soket dari .poll,
tulis mereka sys.stdoutdiikuti \n(jangan siram), tutup soket klien.

Batasi jumlah soket yang dibuka secara bersamaan - menangani kesalahan saat soket dibuat. Buat soket baru hanya jika yang lain ditutup.
Sesuaikan batas OS.
Coba gunakan beberapa proses (tidak banyak): ini mungkin membantu menggunakan CPU sedikit lebih efektif.

Untuk kasus Anda, threading mungkin akan melakukan trik karena Anda mungkin akan menghabiskan sebagian besar waktu menunggu jawaban. Ada modul bermanfaat seperti Antrian di perpustakaan standar yang mungkin membantu.

Saya melakukan hal yang sama dengan mengunduh file secara paralel sebelumnya dan itu cukup baik untuk saya, tetapi itu tidak pada skala yang Anda bicarakan.

Jika tugas Anda lebih terikat CPU, Anda mungkin ingin melihat modul multiprosesing , yang akan memungkinkan Anda untuk memanfaatkan lebih banyak CPU / core / utas (lebih banyak proses yang tidak akan memblokir satu sama lain karena penguncian adalah per proses)

Pertimbangkan untuk menggunakan Windmill , walaupun Windmill mungkin tidak dapat melakukan banyak thread.

Anda bisa melakukannya dengan skrip Python digulung tangan pada 5 mesin, masing-masing menghubungkan keluar menggunakan port 40000-60000, membuka 100.000 koneksi port.

Juga, mungkin membantu untuk melakukan uji sampel dengan aplikasi QA yang diulir dengan baik seperti OpenSTA untuk mendapatkan gambaran tentang seberapa banyak yang dapat ditangani oleh setiap server.

Selain itu, coba lihat menggunakan Perl sederhana dengan kelas LWP :: ConnCache. Anda mungkin akan mendapatkan lebih banyak kinerja (lebih banyak koneksi) dengan cara itu.

Klien web bengkok async ini berjalan cukup cepat.

#!/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)

Saya menemukan bahwa menggunakan tornadopaket menjadi cara tercepat dan termudah untuk mencapai ini:

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])

Cara termudah adalah dengan menggunakan pustaka threading bawaan Python. Mereka bukan "nyata" / utas kernel. Mereka memiliki masalah (seperti serialisasi), tetapi cukup baik. Anda ingin antrian & kumpulan utas. Satu opsi ada di sini , tetapi sepele untuk menulis sendiri. Anda tidak dapat memparalelkan semua 100.000 panggilan, tetapi Anda dapat mematikan 100 (atau lebih) dari mereka secara bersamaan.