Chúng tôi muốn biết thuật toán mà lưới Docker sử dụng để định tuyến các yêu cầu đến các vùng chứa. Đây là lý do tại sao:

Chúng tôi triển khai các ứng dụng của mình cho bầy docker tự lưu trữ. Chúng tôi sử dụng lưới định tuyến docker để hướng lưu lượng truy cập đến các nút riêng lẻ, như thế này:

• internet ->
• tường lửa ->
• giám đốc tải (nginx) ->
• định tuyến nginx "ít kết nối nhất" tới ba trình quản lý bầy đàn ->
• lưới docker ->
• Bất kỳ vùng chứa nào trong số sáu vùng chứa ứng dụng chạy trên ba nút docker không phải người quản lý khác nhau

Các nhà phát triển của chúng tôi nghi ngờ rằng lưới docker đang định tuyến lưu lượng truy cập vòng quanh, điều này có thể dẫn đến việc một số vùng chứa ứng dụng bị quá tải với các yêu cầu chậm trong khi các vùng chứa khác không được sử dụng hết. Nếu các nhà phát triển đúng, chúng ta không nên sử dụng lưới docker và thay vào đó nên sử dụng giám đốc tải để hướng lưu lượng truy cập đến các vùng chứa riêng lẻ bằng thuật toán thông minh hơn so với vòng tròn.

Mặt khác, nếu lưới docker đang theo dõi có bao nhiêu yêu cầu đang bay đến từng vùng chứa và phân phối lưu lượng truy cập đến vùng chứa với ít yêu cầu nhất, thì chúng ta không cần thực hiện công việc bỏ qua lưới docker.

Câu hỏi

Lưới docker sử dụng thuật toán nào để hướng lưu lượng truy cập đến các vùng chứa có sẵn? Nó có phải là vòng tròn tính điểm đơn giản không?

Cấu hình nginx của chúng tôi

Nginx của chúng tôi nhận lưu lượng truy cập từ internet và ủy quyền cho lưới docker trên bất kỳ nút nào trong ba nút trình quản lý docker:

ngược dòng document_service {
  less_conn;
  máy chủ dockermgr1.nosuchdomain:8402;
  máy chủ dockermgr2.nosuchdomain:8402;
  máy chủ dockermgr3.nosuchdomain:8402;
}

người phục vụ {
...
        proxy_pass http://document_service;

Cấu hình docker-compose của chúng tôi

Tệp docker-compose định cấu hình dịch vụ để có sáu bản sao trên ba nút trình chạy docker:

phiên bản: "3.4"

dịch vụ:
  dịch vụ tài liệu:
    hình ảnh: ${IMAGE_LOCATION}documents_service/documentsservice:prod-${COMPOSE_BUILD_TAG:-latest}
    container_name: dịch vụ tài liệu
    cổng:
      - "8402:80"
    ...
    triển khai:
      bản sao: 6
      vị trí:
        ràng buộc: [node.role != manager]
      tài nguyên:
        Hạn mức:
          bộ nhớ: 1024MB
      cập nhật_config:
        song song: 1
        thứ tự: bắt đầu trước
        fail_action: tiếp tục

phiên bản

• docker-ce 5:19.03.12~3-0~debian-buster
• nginx-đầy đủ 1.14.2-2+deb10u4
• docker-soạn thảo: 1.27.4

Mesh routing is most likely round robin only

I took a dive into the docker source. I found references to various routing methods, but the only one that appears to be used is round robin. I also found a question on the docker forum that seems to confirm that mesh routing is round-robin only.

Examining the source

In vendor/github.com/moby/ipvs/constants.go is this interesting list of routing strategies:

const (                                                                                                                                                                                        
        // RoundRobin distributes jobs equally amongst the available                                                                                                                           
        // real servers.                                                                                                                                                                       
        RoundRobin = "rr"                                                                                                                                                                      
                                                                                                                                                                                               
        // LeastConnection assigns more jobs to real servers with                                                                                                                              
        // fewer active jobs.                                                                                                                                                                  
        LeastConnection = "lc"                                                                                                                                                                 
                                                                                                                                                                                               
        // DestinationHashing assigns jobs to servers through looking                                                                                                                          
        // up a statically assigned hash table by their destination IP                                                                                                                         
        // addresses.                                                                                                                                                                          
        DestinationHashing = "dh"                                                                                                                                                              
                                                                                                                                                                                               
        // SourceHashing assigns jobs to servers through looking up                                                                                                                            
        // a statically assigned hash table by their source IP                                                                                                                                 
        // addresses.                                                                                                                                                                          
        SourceHashing = "sh"                                                                                                                                                                   
                                                                                                                                                                                               
        // WeightedRoundRobin assigns jobs to real servers proportionally                                                                                                                      
        // to there real servers' weight. Servers with higher weights                                                                                                                          
        // receive new jobs first and get more jobs than servers                                                                                                                               
        // with lower weights. Servers with equal weights get                                                                                                                                  
        // an equal distribution of new jobs                                                                                                                                                   
        WeightedRoundRobin = "wrr"                                                                                                                                                             
                                                                                                                                                                                               
        // WeightedLeastConnection assigns more jobs to servers                                                                                                                                
        // with fewer jobs and relative to the real servers' weight                                                                                                                            
        WeightedLeastConnection = "wlc"                                                                                                                                                        
)  

However the only one of these constants that is every used is 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

Although this was a very cursory look at the source, I found no obvious means of configuring the routing mode to be anything other than RoundRobin.

A related question on the docker forums

A question on the docker forum seems to confirm that the only routing method available to the mesh is round robin:

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

I’ve read that the swarm mode routing mesh load balancer uses round-robin (https://success.docker.com/article/ucp-service-discovery#externalloadbalancing(swarmmoderoutingmesh) 15).

Is there a possibility to configure the load balancing method (e.g. (weighted) least connection, source/destination hashing…) of the swarm mode routing mesh?

The answer was:

The swarm mode routing mesh aka ingress acts on layer4 and does not know about those configuration details you ask for. The documentation can be found here: https://docs.docker.com/engine/swarm/ingress/ 45. The link you pasted is aimed towards “why using the interlock proxy as advantages”.

If you have an enterprise license: you are entitled to use the interlock proxy, which is part of UCP. It is a layer7 reverse proxy/loadbalancer. Back in the days when I tried early versions of interlock it had some limitiations. From what i read in the change log the current versions seem to be close what traefik is capable to do.

If you are running on Docker-CE, you might want to take a look at traefik.