python分布式

① python如何搭建分布式爬蟲呀

爬蟲本質上不需要分布式。因為你要爬一個網站通常5-10個線程足夠了，再多就是對網站壓力測試了。

你只需要將任務分配到不同的機器上，然後各運行各自己的，結果合並一下就可以。 這個與nutch人map, rese也沒有什麼差別。只是手工分，手工合並。當然也可以用腳本分，腳本合並，腳本遠程啟動。有一個遠程式控制制模塊，似乎叫rpy。很簡單，很容易上手。可以遠程式控制制一個模塊。

資料庫用postgresql不是很好。因為爬行結果放在關系型資料庫里太吃力。特別是網頁內容。通常是URL放在redis里。 內容放在文件系統里，你可以用hadoop+hdfs+thrift方案放在hadoop里。

如果使用了hadoop，就乾脆模仿nutch的流程，把python腳本也交給hadoop去管理好了。
至於控制與通信這個都讓hadoop來處理好了。

當然我個人覺著rpy方式更簡單。 裡面控制與通信都是現成的。10分鍾就學會了。

還是回到原來的說法，大部分情況下，單機多線程跑爬蟲足夠用了。 不需要分布式。而且效率甚至比分布式更高。

② 如何用 python 構建一個簡單的分布式系統

從GitHub中整理出的15個最受歡迎的Python開源框架。這些框架包括事件I/O，OLAP，Web開發，高性能網路通信，測試，爬蟲等。

Django: Python Web應用開發框架
Django 應該是最出名的Python框架，GAE甚至Erlang都有框架受它影響。Django是走大而全的方向，它最出名的是其全自動化的管理後台：只需要使用起ORM，做簡單的對象定義，它就能自動生成資料庫結構、以及全功能的管理後台。

Diesel：基於Greenlet的事件I/O框架
Diesel提供一個整潔的API來編寫網路客戶端和伺服器。支持TCP和UDP。

Flask：一個用Python編寫的輕量級Web應用框架
Flask是一個使用Python編寫的輕量級Web應用框架。基於Werkzeug WSGI工具箱和Jinja2
模板引擎。Flask也被稱為「microframework」，因為它使用簡單的核心，用extension增加其他功能。Flask沒有默認使用的數
據庫、窗體驗證工具。

Cubes：輕量級Python OLAP框架
Cubes是一個輕量級Python框架，包含OLAP、多維數據分析和瀏覽聚合數據（aggregated data）等工具。

Kartograph.py：創造矢量地圖的輕量級Python框架
Kartograph是一個Python庫，用來為ESRI生成SVG地圖。Kartograph.py目前仍處於beta階段，你可以在virtualenv環境下來測試。

Pulsar：Python的事件驅動並發框架
Pulsar是一個事件驅動的並發框架，有了pulsar，你可以寫出在不同進程或線程中運行一個或多個活動的非同步伺服器。

Web2py：全棧式Web框架
Web2py是一個為Python語言提供的全功能Web應用框架，旨在敏捷快速的開發Web應用，具有快速、安全以及可移植的資料庫驅動的應用，兼容Google App Engine。

Falcon：構建雲API和網路應用後端的高性能Python框架
Falcon是一個構建雲API的高性能Python框架，它鼓勵使用REST架構風格，盡可能以最少的力氣做最多的事情。

Dpark：Python版的Spark
DPark是Spark的Python克隆，是一個Python實現的分布式計算框架，可以非常方便地實現大規模數據處理和迭代計算。DPark由豆瓣實現，目前豆瓣內部的絕大多數數據分析都使用DPark完成，正日趨完善。

Buildbot：基於Python的持續集成測試框架
Buildbot是一個開源框架，可以自動化軟體構建、測試和發布等過程。每當代碼有改變，伺服器要求不同平台上的客戶端立即進行代碼構建和測試，收集並報告不同平台的構建和測試結果。

Zerorpc：基於ZeroMQ的高性能分布式RPC框架
Zerorpc是一個基於ZeroMQ和MessagePack開發的遠程過程調用協議（RPC）實現。和 Zerorpc 一起使用的 Service API 被稱為 zeroservice。Zerorpc 可以通過編程或命令行方式調用。

Bottle: 微型Python Web框架
Bottle是一個簡單高效的遵循WSGI的微型python Web框架。說微型，是因為它只有一個文件，除Python標准庫外，它不依賴於任何第三方模塊。

Tornado：非同步非阻塞IO的Python Web框架
Tornado的全稱是Torado Web Server，從名字上看就可知道它可以用作Web伺服器，但同時它也是一個Python Web的開發框架。最初是在FriendFeed公司的網站上使用，FaceBook收購了之後便開源了出來。

webpy: 輕量級的Python Web框架
webpy的設計理念力求精簡（Keep it simple and powerful），源碼很簡短，只提供一個框架所必須的東西，不依賴大量的第三方模塊，它沒有URL路由、沒有模板也沒有資料庫的訪問。

Scrapy：Python的爬蟲框架
Scrapy是一個使用Python編寫的，輕量級的，簡單輕巧，並且使用起來非常的方便。

③ python 分布式進程用的多嗎

Python提供了非常好用的多進程包multiprocessing，你只需要定義一個函數，Python會替你完成其他所有事情。
藉助這個包，可以輕松完成從單進程到並發執行的轉換。
1、新建單一進程
如果我們新建少量進程，可以如下：
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if __name__ == "__main__":
p = multiprocessing.Process(target=func, args=("hello", ))
p.start()
p.join()
print "Sub-process done."12345678910111213
2、使用進程池
是的，你沒有看錯，不是線程池。它可以讓你跑滿多核CPU，而且使用方法非常簡單。
注意要用apply_async，如果落下async，就變成阻塞版本了。
processes=4是最多並發進程數量。
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
if __name__ == "__main__":
pool = multiprocessing.Pool(processes=4)
for i in xrange(10):
msg = "hello %d" %(i)
pool.apply_async(func, (msg, ))
pool.close()
pool.join()
print "Sub-process(es) done."12345678910111213141516
3、使用Pool，並需要關注結果
更多的時候，我們不僅需要多進程執行，還需要關注每個進程的執行結果，如下：
import multiprocessing
import time
def func(msg):
for i in xrange(3):
print msg
time.sleep(1)
return "done " + msg
if __name__ == "__main__":
pool = multiprocessing.Pool(processes=4)
result = []
for i in xrange(10):
msg = "hello %d" %(i)
result.append(pool.apply_async(func, (msg, )))
pool.close()
pool.join()
for res in result:
print res.get()
print "Sub-process(es) done."
2014.12.25更新
根據網友評論中的反饋，在Windows下運行有可能崩潰(開啟了一大堆新窗口、進程)，可以通過如下調用來解決：
multiprocessing.freeze_support()1
附錄（自己的腳本）：
#!/usr/bin/python
import threading
import subprocess
import datetime
import multiprocessing
def dd_test(round, th):
test_file_arg = 'of=/zbkc/test_mds_crash/1m_%s_%s_{}' %(round, th)
command = "seq 100 | xargs -i dd if=/dev/zero %s bs=1M count=1" %test_file_arg
print command
subprocess.call(command,shell=True,stdout=open('/dev/null','w'),stderr=subprocess.STDOUT)
def mds_stat(round):
p = subprocess.Popen("zbkc mds stat", shell = True, stdout = subprocess.PIPE)
out = p.stdout.readlines()
if out[0].find('active') != -1:
command = "echo '0205pm %s round mds status OK, %s' >> /round_record" %(round, datetime.datetime.now())
command_2 = "time (ls /zbkc/test_mds_crash/) 2>>/round_record"
command_3 = "ls /zbkc/test_mds_crash | wc -l >> /round_record"
subprocess.call(command,shell=True)
subprocess.call(command_2,shell=True)
subprocess.call(command_3,shell=True)
return 1
else:
command = "echo '0205 %s round mds status abnormal, %s, %s' >> /round_record" %(round, out[0], datetime.datetime.now())
subprocess.call(command,shell=True)
return 0
#threads = []
for round in range(1, 1600):
pool = multiprocessing.Pool(processes = 10) #使用進程池
for th in range(10):
# th_name = "thread-" + str(th)
# threads.append(th_name) #添加線程到線程列表
# threading.Thread(target = dd_test, args = (round, th), name = th_name).start() #創建多線程任務
pool.apply_async(dd_test, (round, th))
pool.close()
pool.join()
#等待線程完成
# for t in threads:
# t.join()
if mds_stat(round) == 0:
subprocess.call("zbkc -s",shell=True)
break

④ python分布式爬蟲是什麼意思

一、分布式爬蟲架構

在了解分布式爬蟲架構之前，首先回顧一下Scrapy的架構，如下圖所示。

我們需要做的就是在多台主機上同時運行爬蟲任務協同爬取，而協同爬取的前提就是共享爬取隊列。這樣各台主機就不需要各自維護爬取隊列，而是從共享爬取隊列存取Request。但是各台主機還是有各自的Scheler和Downloader，所以調度和下載功能分別完成。如果不考慮隊列存取性能消耗，爬取效率還是會成倍提高。

二、維護爬取隊列

那麼這個隊列用什麼來維護？首先需要考慮的就是性能問題。我們自然想到的是基於內存存儲的Redis，它支持多種數據結構，例如列表（List）、集合（Set）、有序集合（Sorted Set）等，存取的操作也非常簡單。

Redis支持的這幾種數據結構存儲各有優點。

• 列表有lpush()、lpop()、rpush()、rpop()方法，我們可以用它來實現先進先出式爬取隊列，也可以實現先進後出棧式爬取隊列。

• 集合的元素是無序的且不重復的，這樣我們可以非常方便地實現隨機排序且不重復的爬取隊列。

• 有序集合帶有分數表示，而Scrapy的Request也有優先順序的控制，我們可以用它來實現帶優先順序調度的隊列。

我們需要根據具體爬蟲的需求來靈活選擇不同的隊列。

三、如何去重

Scrapy有自動去重，它的去重使用了Python中的集合。這個集合記錄了Scrapy中每個Request的指紋，這個指紋實際上就是Request的散列值。我們可以看看Scrapy的源代碼，如下所示：




importhashlib
defrequest_fingerprint(request, include_headers=None):
ifinclude_headers:
include_headers = tuple(to_bytes(h.lower())
forhinsorted(include_headers))
cache = _fingerprint_cache.setdefault(request, {})
ifinclude_headersnotincache:
fp = hashlib.sha1()
fp.update(to_bytes(request.method))
fp.update(to_bytes(canonicalize_url(request.url)))
fp.update(request.bodyorb'')
ifinclude_headers:
forhdrininclude_headers:
ifhdrinrequest.headers:
fp.update(hdr)
forvinrequest.headers.getlist(hdr):
fp.update(v)
cache[include_headers] = fp.hexdigest()
returncache[include_headers]

request_fingerprint()就是計算Request指紋的方法，其方法內部使用的是hashlib的sha1()方法。計算的欄位包括Request的Method、URL、Body、Headers這幾部分內容，這里只要有一點不同，那麼計算的結果就不同。計算得到的結果是加密後的字元串，也就是指紋。每個Request都有獨有的指紋，指紋就是一個字元串，判定字元串是否重復比判定Request對象是否重復容易得多，所以指紋可以作為判定Request是否重復的依據。

那麼我們如何判定重復呢？Scrapy是這樣實現的，如下所示：




def__init__(self):
self.fingerprints = set()

defrequest_seen(self, request):
fp = self.request_fingerprint(request)
iffpinself.fingerprints:
returnTrue
self.fingerprints.add(fp)

在去重的類RFPDupeFilter中，有一個request_seen()方法，這個方法有一個參數request，它的作用就是檢測該Request對象是否重復。這個方法調用request_fingerprint()獲取該Request的指紋，檢測這個指紋是否存在於fingerprints變數中，而fingerprints是一個集合，集合的元素都是不重復的。如果指紋存在，那麼就返回True，說明該Request是重復的，否則這個指紋加入到集合中。如果下次還有相同的Request傳遞過來，指紋也是相同的，那麼這時指紋就已經存在於集合中，Request對象就會直接判定為重復。這樣去重的目的就實現了。

Scrapy的去重過程就是，利用集合元素的不重復特性來實現Request的去重。

對於分布式爬蟲來說，我們肯定不能再用每個爬蟲各自的集合來去重了。因為這樣還是每個主機單獨維護自己的集合，不能做到共享。多台主機如果生成了相同的Request，只能各自去重，各個主機之間就無法做到去重了。

那麼要實現去重，這個指紋集合也需要是共享的，Redis正好有集合的存儲數據結構，我們可以利用Redis的集合作為指紋集合，那麼這樣去重集合也是利用Redis共享的。每台主機新生成Request之後，把該Request的指紋與集合比對，如果指紋已經存在，說明該Request是重復的，否則將Request的指紋加入到這個集合中即可。利用同樣的原理不同的存儲結構我們也實現了分布式Reqeust的去重。

四、防止中斷

在Scrapy中，爬蟲運行時的Request隊列放在內存中。爬蟲運行中斷後，這個隊列的空間就被釋放，此隊列就被銷毀了。所以一旦爬蟲運行中斷，爬蟲再次運行就相當於全新的爬取過程。


要做到中斷後繼續爬取，我們可以將隊列中的Request保存起來，下次爬取直接讀取保存數據即可獲取上次爬取的隊列。我們在Scrapy中指定一個爬取隊列的存儲路徑即可，這個路徑使用JOB_DIR變數來標識，我們可以用如下命令來實現：




scrapy crawl spider -s JOB_DIR=crawls/spider

更加詳細的使用方法可以參見官方文檔，鏈接為：https://doc.scrapy.org/en/latest/topics/jobs.html。

在Scrapy中，我們實際是把爬取隊列保存到本地，第二次爬取直接讀取並恢復隊列即可。那麼在分布式架構中我們還用擔心這個問題嗎？不需要。因為爬取隊列本身就是用資料庫保存的，如果爬蟲中斷了，資料庫中的Request依然是存在的，下次啟動就會接著上次中斷的地方繼續爬取。

所以，當Redis的隊列為空時，爬蟲會重新爬取；當Redis的隊列不為空時，爬蟲便會接著上次中斷之處繼續爬取。

五、架構實現

我們接下來就需要在程序中實現這個架構了。首先實現一個共享的爬取隊列，還要實現去重的功能。另外，重寫一個Scheer的實現，使之可以從共享的爬取隊列存取Request。


幸運的是，已經有人實現了這些邏輯和架構，並發布成叫Scrapy-Redis的Python包。接下來，我們看看Scrapy-Redis的源碼實現，以及它的詳細工作原理

⑤ 哪些分布式文件系統是由Python編寫的呢

我知道分布式文件系統完全用Python 寫的只有openstack 的swift。

其他還有一些不知名的分布式文件系統用python 寫的如：
NCFS（基於多個雲存儲的分布式文件系統）
一般考慮性能都不會採用python 作為分布式文件系統的開發語言

⑥ 一般Python的分布式計算用什麼框架

(1) 用什麼語言都不能證明逼格，包括匯編，也包括lisp/haskell。
(2) 在適當的場合用適當的工具，解除耦合、減少重復、易於擴展才是對逼格的更高挑戰。
比如有一組件對資料庫有大量操作，我同事認為他要用C++模板元編程加上一些巧妙的設計模式來生成sql是逼格高的體現，我認為在這樣的場景下至少要用上orm才能談得上對逼格有要求。

⑦ grpc使用python時，想做分布式部署，實現負載平衡，求詳細方案

⑧ 如何設計一個python分布式爬蟲系統

你都沒想明白為什麼要分布式
========================
我還是認真答一下吧，爬蟲這種東西在大批量抓去時主要有下面幾個量變引發質變的挑戰：
1. 出口IP數量，主要是考慮防止被封禁，帶寬反而不是大問題，這個問題可以通過搭建NAT出口集群，或者單機多IP的方式實現
2. 本地埠號耗盡，由於爬蟲是服務端編程不太常見的主動發起連接的應用，在普通只有一個IP綁定的機器上會受到65535的限制（一般在50000多就會受到限制）
3. 大容量存儲的需求，一般都是通過開源或者自己研發的分布式存儲系統來實現，像谷歌（GFS）和網路（百靈）都是自研，這里就不展開說了
4. 動態網頁的支持，像京東這種網站，內容都是通過類似Facebook的bigpipe一樣動態載入的，直接像curl這樣抓取看到的頁面幾乎是空白的，這就要求爬蟲能模擬JS的運行，這方面有很多基於v8引擎的開源項目：
CasperJS, a navigation scripting and testing utility for PhantomJS and SlimerJS
PhantomJS | PhantomJS
由於這個需求，爬蟲成了CPU密集型的應用了，分布式的需求也就有了
單機爬蟲的主要難點在的非同步非阻塞網路編程，老生常談了。先暫時寫這么多吧

⑨ 如何用Python寫一個分布式爬蟲

學習 基本的爬蟲工作原理 基本的http抓取工具，scrapy Bloom Filter: Bloom Filters by Example 如果需要大規模網頁抓取，你需要學習分布式爬蟲的概念。其實沒那麼玄乎，你只要學會怎樣維護一個所有集群機器能夠有效分享的分布式隊列就好