Python'da 100.000 HTTP isteği göndermenin en hızlı yolu nedir?

100.000 URL'ye sahip bir dosya açıyorum. Her URL'ye bir HTTP isteği göndermem ve durum kodunu yazdırmam gerekiyor. Ben Python 2.6 kullanıyorum ve şimdiye kadar Python diş / eşzamanlılık uygulayan birçok kafa karıştırıcı yollarına baktı. Python eşzamanlama kütüphanesine bile baktım , ancak bu programı nasıl doğru yazacağımı anlayamıyorum. Benzer bir sorunla karşılaşan var mı? Genel olarak Python'da binlerce görevi mümkün olan en hızlı şekilde nasıl yapacağımı bilmem gerekiyor - sanırım 'eşzamanlı' anlamına geliyor.

Bükümsüz çözüm:

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)

Bu, bükülmüş çözümden biraz daha hızlıdır ve daha az CPU kullanır.

Kasırga eşzamansız ağ kitaplığı kullanan bir çözüm

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

Bu yayınlanmıştır 2010 yılından bu yana işler biraz değişti ve diğer tüm cevapları denemedim ama birkaç denedim ve python3.6 kullanarak benim için en iyi çalışmak için buldum.

AWS'de çalışan saniyede yaklaşık 150 benzersiz alan getirebildim.

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

Konular kesinlikle bu sorunun cevabı değil. Hem hedef hem de çekirdek darboğazlarının yanı sıra, genel hedef "en hızlı yol" ise kabul edilemeyen işlem sınırlarını sağlayacaktır.

Biraz twistedve onun eşzamansız HTTPistemcisi size çok daha iyi sonuçlar verecektir.

Bu eski bir soru olacak ama Python 3.7 de bunu kullanarak yapabilirsiniz asynciove 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))

Bununla ilgili daha fazla bilgi edinebilir ve burada bir örnek görebilirsiniz .

Grequests kullanın , bu isteklerin bir kombinasyonu + Gevent modülü.

GRequests, zaman uyumsuz HTTP İsteklerini kolayca yapmak için Gevent ile İstekleri kullanmanızı sağlar.

Kullanımı basit:

import grequests

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

Gönderilmemiş İstekler kümesi oluşturun:

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

Hepsini aynı anda gönderin:

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

Bu sorunu çözmek için iyi bir yaklaşım, önce bir sonuç elde etmek için gerekli kodu yazmak, daha sonra uygulamayı paralelleştirmek için iş parçacığı kodunu dahil etmektir.

Mükemmel bir dünyada, bu, daha sonra işlenmek üzere sonuçlarını bir sözlüğe veya listeye aktaran 100.000 iş parçacığının aynı anda başlatılması anlamına gelir, ancak uygulamada, bu şekilde kaç paralel HTTP isteği yayınlayabileceğinizle sınırlısınız. Yerel olarak, aynı anda kaç soket açabileceğiniz, Python yorumlayıcınızın kaç yürütme iş parçasına izin vereceği konusunda sınırlarınız var. Uzaktan, tüm istekler bir veya birden fazla sunucuya karşı ise, eşzamanlı bağlantı sayısıyla sınırlı olabilirsiniz. Bu sınırlamalar, muhtemelen komut dosyasını, URL'lerin küçük bir bölümünü herhangi bir anda yok edecek şekilde yazmanızı gerektirecektir (100, bahsedilen başka bir poster gibi, muhtemelen iyi bir iş parçacığı havuzu boyutudur). başarıyla uygulayabilir).

Yukarıdaki sorunu çözmek için bu tasarım desenini takip edebilirsiniz:

1. Şu anda çalışan iş parçacığı sayısına kadar yeni bir iş parçacığı başlatan bir iş parçacığı başlatın (bunları threading.active_count () aracılığıyla veya iş parçacığı nesnelerini bir veri yapısına iterek izleyebilirsiniz)> = maksimum eşzamanlı istek sayınız (100 diyelim) , sonra kısa bir zaman aşımı süresi için uyur. İşlenecek başka URL olmadığında bu iş parçacığı sonlandırılmalıdır. Böylece, iplik uyanmaya, yeni iplik başlatmaya ve bitene kadar uyumaya devam edecektir.
2. İstek iş parçacıklarının sonuçlarını daha sonra almak ve çıktı almak için bazı veri yapılarında saklamasını sağlayın. Yapı Sonuçları saklamak durumunda olduğu bir listveya dictCPython içinde yapabilirsiniz güvenle ekleme veya kilitleri olmadan parçacığı benzersiz öğeleri ekleme bir dosyaya yazma veya daha karmaşık çapraz iplik veri etkileşiminde gerektiriyorsa, ama sen kullanmalısınız bu durumu yolsuzluktan korumak için karşılıklı dışlama kilidi .

İplik geçirme modülünü kullanmanızı öneririm . Çalışan iş parçacıklarını başlatmak ve izlemek için kullanabilirsiniz. Python'un diş açma desteği çıplak, ancak probleminizin açıklaması, ihtiyaçlarınız için tamamen yeterli olduğunu gösteriyor.

Son olarak, Python'da yazılmış bir paralel ağ uygulamasının oldukça basit bir uygulamasını görmek istiyorsanız, ssh.py'ye bakın . Birçok SSH bağlantısını paralelleştirmek için Python iş parçacığını kullanan küçük bir kütüphane. Tasarım, iyi bir kaynak olarak bulabileceğiniz gereksinimlerinize yeterince yakın.

Mümkün olan en iyi performansı elde etmek istiyorsanız, iş parçacıkları yerine Asenkron I / O kullanmayı düşünebilirsiniz. Binlerce işletim sistemi iş parçacığıyla ilişkili ek yük önemsiz değildir ve Python yorumlayıcısı içindeki bağlam geçişi bunun üzerine daha da fazlasını ekler. Diş çekme işi kesinlikle halledecektir, ancak asenkron yolun daha iyi genel performans sağlayacağından şüpheleniyorum.

Özellikle, Twisted kütüphanesinde ( http://www.twistedmatrix.com ) zaman uyumsuz web istemcisini öneririm . Kuşkusuz dik bir öğrenme eğrisi vardır, ancak Twisted'ın eşzamansız programlama tarzını iyi bir şekilde ele aldığınızda kullanımı oldukça kolaydır.

Bir HowTo on Twisted'ın eşzamansız web istemcisi API'sını şu adreste bulabilirsiniz:

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

Bir çözüm:

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

Test zamanı:

[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

Bir iş parçacığı havuzu kullanmak iyi bir seçenektir ve bunu oldukça kolaylaştıracaktır. Ne yazık ki, python, iş parçacığı havuzlarını son derece kolaylaştıran standart bir kütüphaneye sahip değil. Ama işte başlamanız gereken iyi bir kütüphane: http://www.chrisarndt.de/projects/threadpool/

Sitelerinden kod örneği:

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

Bu yardımcı olur umarım.

Create epollnesne,
açık, birçok istemci TCP soketleri
istek başlığında biraz daha olmak onların gönderme tampon ayarlamak,
bir istek başlığı gönderir - bu, sadece bir tampon içine yerleştirerek, acil olması halinde soketi kayıt etmelidir epollnesne,
do .pollüzerine epollobect,
ilk 3 okuma her soketten gelen baytları .poll, üzerine
yazın ve sys.stdoutardından \n(yıkamayın) istemci soketini kapatın.

Aynı anda açılan soket sayısını sınırlayın - soketler oluşturulduğunda hataları ele alın. Yeni bir soket yalnızca başka bir kapalıysa oluşturun.
İşletim sistemi sınırlarını ayarlayın.
Birkaç (çok değil) işleme girmeyi deneyin: bu, CPU'nun biraz daha etkili kullanılmasına yardımcı olabilir.

Sizin durumunuz için, büyük olasılıkla bir yanıt beklemek için en fazla zaman harcayacağınız için, iş parçacığı muhtemelen işe yarayacaktır. Standart kitaplıkta yardımcı olabilecek Kuyruk gibi yardımcı modüller vardır .

Daha önce dosyaların paralel indirilmesinde de benzer bir şey yaptım ve bu benim için yeterince iyiydi, ama bahsettiğiniz ölçekte değildi.

Göreviniz daha fazla CPU'ya bağlıysa, daha fazla CPU / çekirdek / iş parçacığı (kilitleme işlem başına olduğu için birbirini engellemeyecek daha fazla işlem) kullanmanıza izin verecek olan çoklu işlem modülüne bakmak isteyebilirsiniz.

Kullanmayı düşünün Yeldeğirmeni Yeldeğirmeni muhtemelen birçok konuları yapamaz rağmen.

Her biri 40000-60000 bağlantı noktalarını kullanarak giden bağlantıyı bağlayarak 100.000 bağlantı noktası bağlantısı açan 5 makinede elle haddelenmiş bir Python betiği ile yapabilirsiniz.

Ayrıca, her sunucunun ne kadar işleyebileceğine dair bir fikir edinmek için OpenSTA gibi güzel iş parçacıklı bir KG uygulamasıyla örnek bir test yapmak yardımcı olabilir.

Ayrıca, LWP :: ConnCache sınıfıyla sadece basit Perl'i kullanmayı deneyin. Muhtemelen bu şekilde daha fazla performans (daha fazla bağlantı) elde edersiniz.

Bu bükülmüş asenkron web istemcisi oldukça hızlı gidiyor.

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

Bu tornadopaketi kullanarak bunu başarmanın en hızlı ve en basit yolu olarak buldum :

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

En kolay yol Python'un yerleşik iş parçacığı kitaplığını kullanmaktır. "Gerçek" / çekirdek konuları değiller (serileştirme gibi) sorunları var, ama yeterince iyi. Bir kuyruk ve iş parçacığı havuzu istiyorsunuz. Bir seçenek burada , ancak kendiniz yazmak önemsiz. 100.000 çağrının tümünü paralel hale getiremezsiniz, ancak aynı anda 100 (veya daha fazla) çağrıyı kapatabilirsiniz.