HDFS副本存放、讀取原理

原創 01wang 2018-09-11 08:19

HDFS作爲Hadoop中 的一個分佈式文件系統，而且是專門爲它的MapReduce設計，所以HDFS除了必須滿足自己作爲分佈式文件系統的高可靠性外，還必須爲 MapReduce提供高效的讀寫性能，那麼HDFS是如何做到這些的呢？首先，HDFS將每一個文件的數據進行分塊存儲，同時每一個數據塊又保存有多個 副本，這些數據塊副本分佈在不同的機器節點上，這種數據分塊存儲+副本的策略是HDFS保證可靠性和性能的關鍵，這是因爲：一.文件分塊存儲之後按照數據 塊來讀，提高了文件隨機讀的效率和併發讀的效率；二.保存數據塊若干副本到不同的機器節點實現可靠性的同時也提高了同一數據塊的併發讀效率；三.數據分塊 是非常切合MapReduce中任務切分的思想。在這裏，副本的存放策略又是HDFS實現高可靠性和搞性能的關鍵。

       HDFS採用一種稱爲機架感知的策略來改進數據的可靠性、可用性和網絡帶寬的利用率。通過一個機架感知的過程，NameNode可以確定每一個 DataNode所屬的機架id(這也是NameNode採用NetworkTopology數據結構來存儲數據節點的原因，也是我在前面詳細介紹NetworkTopology類 的原因)。一個簡單但沒有優化的策略就是將副本存放在不同的機架上，這樣可以防止當整個機架失效時數據的丟失，並且允許讀數據的時候充分利用多個機架的帶 寬。這種策略設置可以將副本均勻分佈在集羣中，有利於當組件失效的情況下的均勻負載，但是，因爲這種策略的一個寫操作需要傳輸到多個機架，這增加了寫的代 價。

      在大多數情況下，副本系數是3，HDFS的存放策略是將一個副本存放在本地機架節點上，一個副本存放在同一個機架的另一個節點上，最後一個副本放在不同機 架的節點上。這種策略減少了機架間的數據傳輸，提高了寫操作的效率。機架的錯誤遠遠比節點的錯誤少，所以這種策略不會影響到數據的可靠性和可用性。與此同 時，因爲數據塊只存放在兩個不同的機架上，所以此策略減少了讀取數據時需要的網絡傳輸總帶寬。在這種策略下，副本並不是均勻的分佈在不同的機架上：三分之 一的副本在一個節點上，三分之二的副本在一個機架上，其它副本均勻分佈在剩下的機架中，這種策略在不損害數據可靠性和讀取性能的情況下改進了寫的性能。下 面就來看看HDFS是如何來具體實現這一策略的。

       NameNode是通過類來爲每一分數據塊選擇副本的存放位置的，這個ReplicationTargetChooser的一般處理過程如下：


上面的流程圖詳細的描述了Hadoop-0.2.0版本中副本的存放位置的選擇策略，當然，這當中還有一些細節問題，如：如何選擇一個本地數據節點，如何選擇一個本地機架數據節點等，所以下面我還將繼續展開討論。

1.選擇一個本地節點
        這裏所說的本地節點是相對於客戶端來說的，也就是說某一個用戶正在用一個客戶端來向HDFS中寫數據，如果該客戶端上有數據節點，那麼就應該最優先考慮把正在寫入的數據的一個副本保存在這個客戶端的數據節點上，它即被看做是本地節點，但是如果這個客戶端上的數據節點空間不足或者是當前負載過重，則應該從該數據節點所在的機架中選擇一個合適的數據節點作爲此時這個數據塊的本地節點。另外，如果客戶端上沒有一個數據節點的話，則從整個集羣中隨機選擇一個合適的數據節點作爲此時這個數據塊的本地節點。那麼，如何判定一個數據節點合不合適呢，它是通過isGoodTarget方法來確定的：

isGoodTarget方法來確定的：

 

  1. private boolean isGoodTarget(DatanodeDescriptor node, long blockSize, int maxTargetPerLoc, boolean considerLoad, List<DatanodeDescriptor> results) {  

  2.         

  3.     Log logr = FSNamesystem.LOG;  

  4.     // 節點不可用了   

  5.     if (node.isDecommissionInProgress() || node.isDecommissioned()) {  

  6.       logr.debug("Node "+NodeBase.getPath(node)+ " is not chosen because the node is (being) decommissioned");  

  7.       return false;  

  8.     }  

  9.   

  10.     long remaining = node.getRemaining() - (node.getBlocksScheduled() * blockSize);  

  11.     // 節點剩餘的容量夠不夠   

  12.     if (blockSize* FSConstants.MIN_BLOCKS_FOR_WRITE>remaining) {  

  13.       logr.debug("Node "+NodeBase.getPath(node)+ " is not chosen because the node does not have enough space");  

  14.       return false;  

  15.     }  

  16.         

  17.     // 節點當前的負載情況   

  18.     if (considerLoad) {  

  19.       double avgLoad = 0;  

  20.       int size = clusterMap.getNumOfLeaves();  

  21.       if (size != 0) {  

  22.         avgLoad = (double)fs.getTotalLoad()/size;  

  23.       }  

  24.       if (node.getXceiverCount() > (2.0 * avgLoad)) {  

  25.         logr.debug("Node "+NodeBase.getPath(node)+ " is not chosen because the node is too busy");  

  26.         return false;  

  27.       }  

  28.     }  

  29.         

  30.     // 該節點坐在的機架被選擇存放當前數據塊副本的數據節點過多   

  31.     String rackname = node.getNetworkLocation();  

  32.     int counter=1;  

  33.     for(Iterator<DatanodeDescriptor> iter = results.iterator(); iter.hasNext();) {  

  34.       Node result = iter.next();  

  35.       if (rackname.equals(result.getNetworkLocation())) {  

  36.         counter++;  

  37.       }  

  38.     }  

  39.     if (counter>maxTargetPerLoc) {  

  40.       logr.debug("Node "+NodeBase.getPath(node)+ " is not chosen because the rack has too many chosen nodes");  

  41.       return false;  

  42.     }  

  43.       

  44.     return true;  

  45.   }  

2.選擇一個本地機架節點

   實際上，選擇本地節假節點和遠程機架節點都需要以一個節點爲參考，這樣纔是有意義，所以在上面的流程圖中，我用紅色字體標出了參考點。那麼，ReplicationTargetChooser是如何根據一個節點選擇它的一個本地機架節點呢？
這個過程很簡單，如果參考點爲空，則從整個集羣中隨機選擇一個合適的數據節點作爲此時的本地機架節點；否則就從參考節點所在的機架中隨機選擇一個合適的數據節點作爲此時的本地機架節點，若這個集羣中沒有合適的數據節點的話，則從已選擇的數據節點中找出一個作爲新的參考點，如果找到了一個新的參考點，則從這個新的參考點在的機架中隨機選擇一個合適的數據節點作爲此時的本地機架節點；否則從整個集羣中隨機選擇一個合適的數據節點作爲此時的本地機架節點。如果新的參考點所在的機架中仍然沒有合適的數據節點，則只能從整個集羣中隨機選擇一個合適的數據節點作爲此時的本地機架節點了。

 

  1. <font xmlns="http://www.w3.org/1999/xhtml">private DatanodeDescriptor chooseLocalRack(DatanodeDescriptor localMachine, List<Node> excludedNodes, long blocksize, int maxNodesPerRack, List<DatanodeDescriptor> results)throws NotEnoughReplicasException {  

  2.     // 如果參考點爲空，則從整個集羣中隨機選擇一個合適的數據節點作爲此時的本地機架節點   

  3.     if (localMachine == null) {  

  4.       return chooseRandom(NodeBase.ROOT, excludedNodes, blocksize, maxNodesPerRack, results);  

  5.     }  

  6.         

  7.     //從參考節點所在的機架中隨機選擇一個合適的數據節點作爲此時的本地機架節點   

  8.     try {  

  9.       return chooseRandom(localMachine.getNetworkLocation(), excludedNodes, blocksize, maxNodesPerRack, results);  

  10.     } catch (NotEnoughReplicasException e1) {  

  11.       //若這個集羣中沒有合適的數據節點的話，則從已選擇的數據節點中找出一個作爲新的參考點   

  12.       DatanodeDescriptor newLocal=null;  

  13.       for(Iterator<DatanodeDescriptor> iter=results.iterator(); iter.hasNext();) {  

  14.         DatanodeDescriptor nextNode = iter.next();  

  15.         if (nextNode != localMachine) {  

  16.           newLocal = nextNode;  

  17.           break;  

  18.         }  

  19.       }  

  20.         

  21.       if (newLocal != null) {//找到了一個新的參考點   

  22.         try {  

  23.           //從這個新的參考點在的機架中隨機選擇一個合適的數據節點作爲此時的本地機架節點   

  24.           return chooseRandom(newLocal.getNetworkLocation(), excludedNodes, blocksize, maxNodesPerRack, results);  

  25.         } catch(NotEnoughReplicasException e2) {  

  26.           //新的參考點所在的機架中仍然沒有合適的數據節點，從整個集羣中隨機選擇一個合適的數據節點作爲此時的本地機架節點   

  27.           return chooseRandom(NodeBase.ROOT, excludedNodes, blocksize, maxNodesPerRack, results);  

  28.         }  

  29.       } else {  

  30.         //從整個集羣中隨機選擇一個合適的數據節點作爲此時的本地機架節點   

  31.         return chooseRandom(NodeBase.ROOT, excludedNodes, blocksize, maxNodesPerRack, results);  

  32.       }  

  33.     }  

  34.   }</font>  

3.選擇一個遠程機架節點
   選擇一個遠程機架節點就是隨機的選擇一個合適的不在參考點坐在的機架中的數據節點，如果沒有找到這個合適的數據節點的話，就只能從參考點所在的機架中選擇一個合適的數據節點作爲此時的遠程機架節點了。

4.隨機選擇若干數據節點
   這裏的隨機隨機選擇若干個數據節點實際上指的是從某一個範圍內隨機的選擇若干個節點，它的實現需要利用前面提到過的NetworkTopology數據結構。隨機選擇所使用的範圍本質上指的是一個路徑，這個路徑表示的是NetworkTopology所表示的樹狀網絡拓撲圖中的一個非葉子節點，隨機選擇針對的就是這個節點的所有葉子子節點，因爲所有的數據節點都被表示成了這個樹狀網絡拓撲圖中的葉子節點。

5.優化數據傳輸的路徑
   以前說過，HDFS對於Block的副本copy採用的是流水線作業的方式：client把數據Block只傳給一個DataNode，這個DataNode收到Block之後，傳給下一個DataNode，依次類推，...，最後一個DataNode就不需要下傳數據Block了。所以，在爲一個數據塊確定了所有的副本存放的位置之後，就需要確定這種數據節點之間流水複製的順序，這種順序應該使得數據傳輸時花費的網絡延時最小。ReplicationTargetChooser用了非常簡單的方法來考量的，大家一看便知：

  1. private DatanodeDescriptor[] getPipeline( DatanodeDescriptor writer, DatanodeDescriptor[] nodes) {  

  2.     if (nodes.length==0) return nodes;  

  3.         

  4.     synchronized(clusterMap) {  

  5.       int index=0;  

  6.       if (writer == null || !clusterMap.contains(writer)) {  

  7.         writer = nodes[0];  

  8.       }  

  9.         

  10.       for(;index<nodes.length; index++) {  

  11.         DatanodeDescriptor shortestNode = nodes[index];  

  12.         int shortestDistance = clusterMap.getDistance(writer, shortestNode);  

  13.         int shortestIndex = index;  

  14.         for(int i=index+1; i<nodes.length; i++) {  

  15.           DatanodeDescriptor currentNode = nodes[i];  

  16.           int currentDistance = clusterMap.getDistance(writer, currentNode);  

  17.           if (shortestDistance>currentDistance) {  

  18.             shortestDistance = currentDistance;  

  19.             shortestNode = currentNode;  

  20.             shortestIndex = i;  

  21.           }  

  22.         }  

  23.         //switch position index & shortestIndex   

  24.         if (index != shortestIndex) {  

  25.           nodes[shortestIndex] = nodes[index];  

  26.           nodes[index] = shortestNode;  

  27.         }  

  28.         writer = shortestNode;  

  29.       }  

  30.     }  

  31.     return nodes;  

  32.   }  

  可惜的是，HDFS目前並沒有把副本存放策略的實現開放給用戶，也就是用戶無法根據自己的實際需求來指定文件的數據塊存放的具體位置。例如：我們可以將有關係的兩個文件放到相同的數據節點上，這樣在進行map-reduce的時候，其工作效率會大大的提高。但是，又考慮到副本存放策略是與集羣負載均衡休慼相關的，所以要是真的把負載存放策略交給用戶來實現的話，對用戶來說是相當負載的

讀取

   HDFS對文件的存儲是分塊來存儲的，即HDFS對於客戶端寫入的數據先按照固 定大小對這些數據進行分塊，然後把每一個數據塊的多個副本存儲在不同的DataNode節點上，同時不同的數據塊也可能存儲在不同的DataNode節點 上。那麼，當客戶端要從HDFS上讀取某個文件時，它又是如何處理的呢？很明顯，客戶端也是按照分塊來讀取文件的數據的，關於客戶端如何分塊讀取文件的詳 細原理與過程我已經在前面的博文中詳細的闡述了，在這裏就不多贅述了。但是，一個數據塊有多個副本，客戶端到底優先讀取那個DataNode節點上的該數 據塊的副本呢？這將是本要所要討論的重點了，即HDFS讀取副本的選擇策略，而這個工作具體是由NameNode來完成的。

    當客戶端讀到一個文件的某個數據塊時，它就需要向NameNode節點詢問這個數據塊存儲在那些DataNode節點上，這個過程如下圖：

 

當然，客戶端至少需要向NameNode傳輸三個參數：文件路徑、讀取文件的起始位置、讀取文件的長度，而NameNode會向該客戶端返回它所要讀取文件內容所在的位置——LocatedBlock對象，該對象包含對應的數據塊所有副本所在的DataNode節點的位置信息，客戶端接着就會依次從這些DataNode節點上讀取該數據塊，直到成功讀取爲止。這裏就設計到了一個優化問題了：客戶端應該總是選擇從距離它最近的可用DataNode節點上讀取需要的數據塊，所以此時的關鍵就是如何來計算客戶端與DataNode節點之間的距離。這個計算距離的問題本質上涉及到我前面介紹過的一種數據結構——NetworkTopology，這種數據結構被NameNode節點用來形象的表示HDFS集羣中所有DataNode節點的物理位置，自然這個優化工作就交由NameNode來處理了。

 

      NameNode對文件的讀優化的實現很簡單，基本原理就是按照客戶端與DataNode節點之間的距離進行排序，距客戶端越近的DataNode節點越被放在LocatedBlock的前面，該算法的基本思路如下：

 

    1.如果該Block的一個副本存在於客戶端，則客戶端優先從本地讀取該數據塊；

 

    2.如果該Block的一個副本與客戶端在同一個機架上，且沒有一個副本存放在客戶端，則客戶端優先讀取這個同機架上的副本；否則客戶端優先讀取同機器的副本，失敗的情況下然後再優先考慮這個同機架上的副本；

 

    3.如果該Block既沒有一個副本存在客戶端，又沒有一個副本與客戶端在同一個機架上，則隨機選擇一個DataNode節點作爲優先節點。


其詳細實現如下：

[java] view plaincopy

  1. /**   

  2.    * @param reader 客戶端 

  3.    * @param nodes 某個Block所在的DataNode節點 

  4.  */  

  5. public void pseudoSortByDistance( Node reader, Node[] nodes ) {  

  6.     int tempIndex = 0;  

  7.     if (reader != null ) {  

  8.       int localRackNode = -1;  

  9.       //scan the array to find the local node & local rack node  

  10.       for(int i=0; i<nodes.length; i++) {  

  11.         if(tempIndex == 0 && reader == nodes[i]) { //local node  

  12.           //swap the local node and the node at position 0  

  13.           if( i != 0 ) {  

  14.             swap(nodes, tempIndex, i);  

  15.           }  

  16.           tempIndex=1;  

  17.           if(localRackNode != -1 ) {  

  18.             if(localRackNode == 0) {  

  19.               localRackNode = i;  

  20.             }  

  21.             break;  

  22.           }  

  23.         } else if(localRackNode == -1 && isOnSameRack(reader, nodes[i])) {  

  24.           //local rack  

  25.           localRackNode = i;  

  26.           if(tempIndex != 0 ) break;  

  27.         }  

  28.       }  

  29.  

  30.       // swap the local rack node and the node at position tempIndex  

  31.       if(localRackNode != -1 && localRackNode != tempIndex ) {  

  32.         swap(nodes, tempIndex, localRackNode);  

  33.         tempIndex++;  

  34.       }  

  35.     }  

  36.       

  37.     // put a random node at position 0 if it is not a local/local-rack node  

  38.     if(tempIndex == 0 && nodes.length != 0) {  

  39.       swap(nodes, 0, r.nextInt(nodes.length));  

  40.     }  

  41.   }  


     從上面的具體實現可以看，這種優化策略存在一個很大的缺陷：完全沒有考慮到DataNode上的負載情況，從而致使HDFS的讀性能急速下降。這一點也正好反映了HDFS還有很大的優化空間，但遺憾的是，HDFS對這種讀Block時的副本選擇策略並沒有開放給開發者，以至於大大的增加了優化的難度。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

（第3篇）HDFS是什麼？HDFS適合做什麼？我們應該怎樣操作HDFS系統？

I加加 2019-02-23 00:38:18

（第2篇）一篇文章教你輕鬆安裝hadoop

I加加 2019-02-23 00:37:53

hadoop一步步入門

lcyuanjiang 2019-02-23 13:59:15

hadoop搭建之hive安裝

伊人心 2019-02-23 00:41:25

（第6.1篇）大數據發展背後的強力推手——HBase分佈式存儲系統

I加加 2019-02-23 00:37:53

（第8篇）實時可靠的開源分佈式實時計算系統——Storm

I加加 2019-02-23 00:37:53

（第7篇）靈活易用易維護的hadoop數據倉庫工具——Hive

I加加 2019-02-23 00:37:51

（第4篇）hadoop之魂--mapreduce計算框架，讓收集的數據產生價值

I加加 2019-02-23 00:37:51

（第1篇）什麼是hadoop大數據？我又爲什麼要寫這篇文章？

I加加 2019-02-23 00:37:51

（第9篇）大數據的的超級應用——數據挖掘-推薦系統

I加加 2019-02-23 00:37:50

（第5篇）避免協作衝突--簡單易接入的Zookeeper

I加加 2019-02-23 00:37:50

hadoop 完全分佈式搭建(帶配置文件)

wangyudiwang 2019-02-23 00:37:11

hbase安裝

chengongliang 2019-02-23 00:28:08

hadoop安裝

chengongliang 2019-02-23 00:28:08

基於spark排序的一種更廉價的實現方案-附基於spark的性能測試

wx58a7bb5e188a6 2019-02-23 00:26:45