Score:2

docker mesh ใช้อัลกอริทึมการกำหนดเส้นทางใด

ธง vu

เราต้องการทราบว่าอัลกอริทึมใดที่ Docker mesh ใช้เพื่อกำหนดเส้นทางคำขอไปยังคอนเทนเนอร์ นี่คือเหตุผล:

เราปรับใช้แอปพลิเคชันของเรากับฝูงนักเทียบท่าที่โฮสต์เอง เราใช้ docker routing mesh เพื่อส่งทราฟฟิกไปยังโหนดแต่ละโหนด ดังนี้:

  • อินเทอร์เน็ต ->
  • ไฟร์วอลล์ ->
  • ผู้อำนวยการโหลด (nginx) ->
  • nginx "การเชื่อมต่อน้อยที่สุด" กำหนดเส้นทางไปยังผู้จัดการ swarm สามคน ->
  • นักเทียบท่าตาข่าย ->
  • คอนเทนเนอร์แอปใดในหกแอปที่ทำงานบนโหนดนักเทียบท่าที่ไม่ใช่ผู้จัดการที่แตกต่างกันสามโหนด

นักพัฒนาของเราสงสัยว่า docker mesh กำลังกำหนดเส้นทางทราฟฟิกแบบ round robin ซึ่งอาจส่งผลให้คอนเทนเนอร์แอปบางแอปโหลดมากเกินไปพร้อมกับคำขอที่ช้า ขณะที่คอนเทนเนอร์อื่นๆ ใช้งานน้อยเกินไป หากผู้พัฒนาถูกต้อง เราไม่ควรใช้ docker mesh และควรใช้ load director เพื่อกำหนดเส้นทางการรับส่งข้อมูลไปยังคอนเทนเนอร์แต่ละรายการโดยใช้อัลกอริทึมที่ชาญฉลาดกว่า round robin

ในทางกลับกัน หาก docker mesh ติดตามจำนวนคำขอที่กำลังส่งไปยังแต่ละคอนเทนเนอร์ และส่งทราฟฟิกไปยังคอนเทนเนอร์ด้วยคำขอน้อยที่สุด เราก็ไม่จำเป็นต้องทำงานข้าม docker mesh

คำถาม

docker mesh ใช้อัลกอริทึมอะไรในการส่งทราฟฟิกไปยังคอนเทนเนอร์ที่มีอยู่ มันเป็นโรบินธรรมดาหรือไม่?

การกำหนดค่า nginx ของเรา

nginx ของเรารับทราฟฟิกจากอินเทอร์เน็ตและพร็อกซีไปยัง docker mesh บนโหนดตัวจัดการนักเทียบท่าใดก็ได้ในสามโหนด:

document_service ต้นน้ำ {
  little_conn;
  เซิร์ฟเวอร์ dockermgr1.nosuchdomain:8402;
  เซิร์ฟเวอร์ dockermgr2.nosuchdomain:8402;
  เซิร์ฟเวอร์ dockermgr3.nosuchdomain:8402;
}

เซิร์ฟเวอร์ {
...
        proxy_pass http://document_service;

การกำหนดค่านักเทียบท่าของเรา

ไฟล์ docker-compose กำหนดค่าบริการให้มีตัวจำลองหกตัวบนโหนดตัวเรียกใช้นักเทียบท่าสามโหนด:

รุ่น: "3.4"

บริการ:
  บริการเอกสาร:
    รูปภาพ: ${IMAGE_LOCATION}documents_service/documentsservice:prod-${COMPOSE_BUILD_TAG:-latest}
    container_name: บริการเอกสาร
    พอร์ต:
      - "8402:80"
    ...
    ปรับใช้:
      แบบจำลอง: 6
      ตำแหน่ง:
        ข้อจำกัด: [node.role != ผู้จัดการ]
      ทรัพยากร:
        ขีด จำกัด :
          หน่วยความจำ: 1024MB
      update_config:
        ความเท่าเทียม: 1
        คำสั่ง: เริ่มก่อน
        Failure_action: ดำเนินการต่อ

รุ่น

  • นักเทียบท่า 5:19.03.12~3-0~debian-buster
  • nginx-เต็ม 1.14.2-2+deb10u4
  • docker-compose: 1.27.4
Score:0
ธง vu

การกำหนดเส้นทางแบบตาข่ายมักจะเป็นแบบ Round robin เท่านั้น

ฉันดำดิ่งลงไปใน แหล่งนักเทียบท่า. ฉันพบการอ้างอิงถึงวิธีการกำหนดเส้นทางต่างๆ แต่วิธีเดียวที่ดูเหมือนจะใช้คือ Round robin ฉันยังพบคำถามในฟอรัมนักเทียบท่าที่ดูเหมือนจะยืนยันว่าการกำหนดเส้นทางแบบตาข่ายนั้นเป็นแบบวนรอบเท่านั้น

ตรวจสอบแหล่งที่มา


ใน vendor/github.com/moby/ipvs/constants.go นี่คือรายการกลยุทธ์การกำหนดเส้นทางที่น่าสนใจ:

คอนสต (                                                                                                                                                                                        
        // RoundRobin กระจายงานอย่างเท่าเทียมกันระหว่างที่มีอยู่                                                                                                                           
        // เซิร์ฟเวอร์จริง                                                                                                                                                                       
        ราวด์โรบิน = "rr"                                                                                                                                                                      
                                                                                                                                                                                               
        // LeastConnection มอบหมายงานเพิ่มเติมให้กับเซิร์ฟเวอร์จริงด้วย                                                                                                                              
        // งานที่ใช้งานน้อยลง                                                                                                                                                                  
        การเชื่อมต่อน้อยที่สุด = "lc"                                                                                                                                                                 
                                                                                                                                                                                               
        // DestinationHashing มอบหมายงานให้กับเซิร์ฟเวอร์ผ่านการค้นหา                                                                                                                          
        // ขึ้นตารางแฮชที่กำหนดแบบคงที่โดย IP ปลายทาง                                                                                                                         
        // ที่อยู่                                                                                                                                                                          
        ปลายทางการแฮช = "dh"                                                                                                                                                              
                                                                                                                                                                                               
        // SourceHashing มอบหมายงานให้กับเซิร์ฟเวอร์ผ่านการค้นหา                                                                                                                            
        // ตารางแฮชที่กำหนดแบบคงที่โดย IP ต้นทาง                                                                                                                                 
        // ที่อยู่                                                                                                                                                                          
        SourceHashing = "sh"                                                                                                                                                                   
                                                                                                                                                                                               
        // WeightedRoundRobin มอบหมายงานให้กับเซิร์ฟเวอร์จริงตามสัดส่วน                                                                                                                      
        // เพื่อให้มีน้ำหนักของเซิร์ฟเวอร์จริง เซิร์ฟเวอร์ที่มีน้ำหนักมากขึ้น                                                                                                                          
        // รับงานใหม่ก่อนและรับงานมากกว่าเซิร์ฟเวอร์                                                                                                                               
        // ด้วยน้ำหนักที่ลดลง เซิร์ฟเวอร์ที่มีน้ำหนักเท่ากันจะได้รับ                                                                                                                                  
        // การกระจายงานใหม่อย่างเท่าเทียมกัน                                                                                                                                                   
        WeightedRoundRobin = "wrr"                                                                                                                                                             
                                                                                                                                                                                               
        // WeightedLeastConnection มอบหมายงานเพิ่มเติมให้กับเซิร์ฟเวอร์                                                                                                                                
        // มีงานน้อยลงและสัมพันธ์กับน้ำหนักของเซิร์ฟเวอร์จริง                                                                                                                            
        การเชื่อมต่อแบบถ่วงน้ำหนัก = "wlc"                                                                                                                                                        
)  

อย่างไรก็ตามค่าคงที่ค่าเดียวที่ใช้ทุกครั้งคือ RoundRobin:

wayne@treebeard:~/temp/docker-src/moby$ ack 'ipvs\.(RoundRobin|LeastConnection|DestinationHashing|SourceHashing|WeightedRoundRobin|WeightedLeastConnection)'
libnetwork/service_linux.go
117: SchedName: ipvs.RoundRobin,
225: s.SchedName = ipvs.RoundRobin

แม้ว่านี่จะเป็นการดูแหล่งที่มาคร่าวๆ แต่ฉันไม่พบวิธีที่ชัดเจนในการกำหนดค่าโหมดการกำหนดเส้นทางให้เป็นอย่างอื่นนอกจาก RoundRobin

คำถามที่เกี่ยวข้องกับฟอรัมนักเทียบท่า

คำถามเกี่ยวกับฟอรัมนักเทียบท่าดูเหมือนจะยืนยันว่าวิธีการกำหนดเส้นทางเดียวที่มีให้สำหรับตาข่ายคือ Round robin:

https://forums.docker.com/t/configure-swarm-mode-routing-mesh-load-balancing-method/75413

ฉันได้อ่านพบว่าตัวโหลดบาลานเซอร์แบบตาข่ายในการกำหนดเส้นทางโหมด swarm ใช้การวนรอบ (https://success.docker.com/article/ucp-service-discovery#externalloadbalancing(swarmmoderoutingmesh) 15).

มีความเป็นไปได้หรือไม่ที่จะกำหนดค่าวิธีโหลดบาลานซ์ (เช่น(ถ่วงน้ำหนัก) การเชื่อมต่อน้อยที่สุด การแฮชต้นทาง/ปลายทางâ¦) ของตาข่ายการกำหนดเส้นทางโหมดสวอร์ม

คำตอบคือ:

ตาข่ายการกำหนดเส้นทางของโหมดสวอร์มหรือที่เรียกว่าขาเข้าทำหน้าที่ในเลเยอร์ 4 และไม่ทราบเกี่ยวกับรายละเอียดการกำหนดค่าที่คุณขอ สามารถดูเอกสารได้ที่นี่: https://docs.docker.com/engine/swarm/ingress/ 45. ลิงก์ที่คุณวางมีจุดประสงค์เพื่อระบุว่า “เหตุใดจึงใช้พร็อกซีแบบเชื่อมต่อระหว่างกันเป็นข้อดี”

หากคุณมีใบอนุญาตสำหรับองค์กร: คุณมีสิทธิ์ใช้พร็อกซีแบบเชื่อมต่อซึ่งเป็นส่วนหนึ่งของ UCP เป็นพร็อกซีย้อนกลับ / ตัวโหลดบาลานซ์เลเยอร์ 7 ย้อนกลับไปสมัยที่ฉันลองใช้อินเตอร์ล็อคเวอร์ชันแรกๆ มันมีข้อจำกัดอยู่บ้าง จากสิ่งที่ฉันอ่านในบันทึกการเปลี่ยนแปลง เวอร์ชันปัจจุบันดูเหมือนจะใกล้เคียงกับที่ traefik สามารถทำได้

หากคุณกำลังใช้งาน Docker-CE คุณอาจต้องการดูที่ traefik

vu flag
นี่เป็นการคาดเดามากกว่าสิ่งใด ดังนั้นอย่าทำเครื่องหมายถูกโดยหวังว่าจะมีคนเขียนคำตอบที่สมควรได้รับมากกว่า

โพสต์คำตอบ

คนส่วนใหญ่ไม่เข้าใจว่าการถามคำถามมากมายจะปลดล็อกการเรียนรู้และปรับปรุงความสัมพันธ์ระหว่างบุคคล ตัวอย่างเช่น ในการศึกษาของ Alison แม้ว่าผู้คนจะจำได้อย่างแม่นยำว่ามีคำถามกี่ข้อที่ถูกถามในการสนทนา แต่พวกเขาไม่เข้าใจความเชื่อมโยงระหว่างคำถามและความชอบ จากการศึกษาทั้ง 4 เรื่องที่ผู้เข้าร่วมมีส่วนร่วมในการสนทนาด้วยตนเองหรืออ่านบันทึกการสนทนาของผู้อื่น ผู้คนมักไม่ตระหนักว่าการถามคำถามจะมีอิทธิพลหรือมีอิทธิพลต่อระดับมิตรภาพระหว่างผู้สนทนา