当前位置:   article > 正文

[Docker]十.Docker Swarm讲解_swarm管理docker

swarm管理docker

一.Dokcer Swarm集群介绍

1.Dokcer Swarm 简介

Docker Swarm Docker 公司推出的用来管理 docker 集群的工具, 使用 Docker Swarm 可以快速方便的实现 高可用集群 ,Docker Compose 只能编排单节点上的容器, Docker Swarm 可以让我们在单一主机上操作来完成对 整个容器集群 的管理工作,使用Docker Swarm 可以 让单一主机上的容器快速部署到10个、20个或者200个主机上面,实现高可用集群. 从 Docker 1.12.0 版本开始, Docker Swarm 已经包含在 Docker 引擎中( docker swarm ),并且
已经内置了服务发现工具,就不需要像之前一样,再配置 Etcd 或者 Consul 来进行服务发现配置了.Dokcer Swarm是 Docker 官方的提供的集群部署管理工具,基于原生 Docker ,相比 K8s 更简单 更容易上手, 如果您的节点(物理机)在1000 台以内,完全可以使用 Docker Swarm 实现部署,学会Docker Swarm,学 K8s 会更简单一些, Swarm Kubernetes 比较类似,但是更加轻,具有的功能也较kubernetes更少一些
  • docker host集群管理工具
  • docker官方提供的
  • docker 1.12版本以后
  • 用来统一集群管理的,把整个集群资源做统一调度
  • kubernetes要轻量化
  • 实现scaling 规模扩大或缩小
  • 实现rolling update 滚动更新或版本回退
  • 实现service discovery 服务发现
  • 实现load balance 负载均衡
  • 实现route mesh 路由网格,服务治理
官网地址: https://docs.docker.com/engine/reference/commandline/swarm/
下面先了解一下相关知识

2.Dokcer Swarm节点

Docker swarm 中有 节点 的概念, 一个节点就可以通俗的理解为一个机器 ( 可以是物理服务器也可以是虚拟机、云等等)

节点分为: 管理 (manager) 节点工作 (worker) 节点 

管理节点(Manager):
        管理节点用于 Swarm 集群的管理 负责集群控制,能过监控集群状态、分发任
务到工作节点 docker swarm 命令基本只能在管理节点执行 (节点退出集群命令 docker swarm leave 可以在工作节点执行), 一个 Swarm 集群可以有多个管理节点 只有一个管理节点可以成为 leader leader 通过 raft 协议实现
工作节点(Worker):
        是任务执行节点,管理节点将服务 (service) 下发至工作节点执行, 管理节点默 认也作为工作节点

节点的有效性有三种:

  • Active 调度程序可以分配任务给节点
  • Pause 调度程序不分配新任务给节点,但现有任务继续运行
  • Drain 调度程序不分配新任务给节点,调度程序关闭任何现有任务并将它们调度到可用节点上

 3.Dokcer Swarm节点数量

(1).管理节

        为了实现高可用Dokcer Swarm 采用了 Raft一致性算法 ,在保证大多数管理节点存活的情况下,集群才能使用,所以就要求如果集群的话, manager节点必须>3台 ,如果是两个台,其中一台宕机,剩余的一台也将不可用,以致整个集群不可用.
        为了利用 swarm 模式的容错特性, Docker 建议根据组织的高可用性要求实现 奇数个节点, 当有多个管理器时,可以从管理器节点的故障中恢复而无需停机
一个三管理器群最多可以容忍一名管理器的损失
一个五管理器群最多可以同时丢失两个管理器节点
一个 N 管理器集群最多可以容忍丢失 (N-1)/2 管理器
Docker 建议 一个 swarm 最多使用 7个管理器 节点

(2).工作节点

        管理节点也可以是工作节点,工作节点的数量没有限制,经过测试,Swarm 可拓展性的极限是在 1000个节点(主机)上运行 50000 个部署容器

4.服务和任务

任务 Task )是 Swarm 中的最小的调度单位,目前来说就是 一个单一的容器
服务 Services ) 是指一组任务的集合( 多个容器的集群 ),服务定义了任务的属性

二.docker swarm集群搭建

1.docker swarm集群准备工作

关闭seLinux、关闭防火墙、配置主机hostname 

关闭SELinux

通过getenforce命令查看SELiunx

  1. [root@MiWiFi-R3L-srv ~]# getenforce
  2. Disabled
  1. 修改/etc/selinux/config 文件
  2. 将SELINUX=enforcing改为SELINUX=disabled

关闭防火墙

  1. #停止防火墙
  2. systemctl stop firewalld
  3. #永久关闭防火墙
  4. #systemctl disable firewalld
  5. #开启防火墙
  6. systemctl start firewalld
  7. #查看防火墙状态
  8. systemctl status firewalld

配置主机hostname

如果只是修改hostname可以通过如下命令

hostname newHostname

注意:
        这种修改方式只有当前有效,等服务器重启后hostname 就会失效,回到原来的 hostname

永久修改,重启后生效  

vi /etc/hostname

2.创建docker swarm集群

这里用四台虚拟机来操作:

        manager  节点 manager_81 192.168.31.81 

        worker     节点 worker_117 192.168.31.117

        worker     节点 worker_140 192.168.31.140

        worker     节点 worker_241 192.168.31.241

关闭他们的SELinux,关闭防火墙,以及设置其hostname

首先就在 manager 这个节点上执行如下操作,表示要将它设置为 manager ,并且设置自己的通讯IP为192.168.31.81,相关命令语法如下:
  1. #docker swarm init 快速初始化一个集群
  2. docker swarm init --advertise-addr 192.168.31.81
  1. [root@manager_81 ~]# docker swarm init --advertise-addr 192.168.31.81
  2. Swarm initialized: current node (qu1ydd2t6occ8fo76rvaksidd) is now a manager.
  3. To add a worker to this swarm, run the following command:
  4. docker swarm join --token SWMTKN-1-6afkz1ub7m8q37cehxmjiirs6a0r25qt1hzf0no1c0xcny55qc-d3gtv0qcsuhivozbomp4d73ha 192.168.31.81:2377
  5. To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
  6. [root@manager_81 ~]

上述的docker swarm join 为加入集群的命令

docker swarm join --token SWMTKN-1-6afkz1ub7m8q37cehxmjiirs6a0r25qt1hzf0no1c0xcny55qc-d3gtv0qcsuhivozbomp4d73ha 192.168.31.81:2377

把上面命令依次在工作节点worker_117,worker_140,worker_241上运行,这样这几个工作节点就加入了集群了

3.查看集群节点

在manager_81管理节点上运行命令 docker node ls 查看所有集群节点
注意:
        该命令只能在manager节点上运行
也可以通过命令  docker node inspect 节点ID  查看节点详情
  1. #查看manager节点信息
  2. [root@manager_81 ~]# docker node inspect qu1ydd2t6occ8fo76rvaksidd
  3. [
  4. {
  5. "ID": "qu1ydd2t6occ8fo76rvaksidd",
  6. "Version": {
  7. "Index": 9
  8. },
  9. "CreatedAt": "2023-11-23T08:52:01.533912216Z",
  10. "UpdatedAt": "2023-11-23T08:52:04.095241126Z",
  11. "Spec": {
  12. "Labels": {},
  13. "Role": "manager",
  14. "Availability": "active"
  15. },
  16. "Description": {
  17. "Hostname": "manager_81",
  18. "Platform": {
  19. "Architecture": "x86_64",
  20. "OS": "linux"
  21. },
  22. "Resources": {
  23. "NanoCPUs": 1000000000,
  24. "MemoryBytes": 819965952
  25. },
  26. "Engine": {
  27. "EngineVersion": "24.0.7",
  28. "Plugins": [
  29. {
  30. "Type": "Log",
  31. "Name": "awslogs"
  32. },
  33. {
  34. "Type": "Log",
  35. "Name": "fluentd"
  36. },
  37. {
  38. "Type": "Log",
  39. "Name": "gcplogs"
  40. },
  41. {
  42. "Type": "Log",
  43. "Name": "gelf"
  44. },
  45. {
  46. "Type": "Log",
  47. "Name": "journald"
  48. },
  49. {
  50. "Type": "Log",
  51. "Name": "json-file"
  52. },
  53. {
  54. "Type": "Log",
  55. "Name": "local"
  56. },
  57. {
  58. "Type": "Log",
  59. "Name": "logentries"
  60. },
  61. {
  62. "Type": "Log",
  63. "Name": "splunk"
  64. },
  65. {
  66. "Type": "Log",
  67. "Name": "syslog"
  68. },
  69. {
  70. "Type": "Network",
  71. "Name": "bridge"
  72. },
  73. {
  74. "Type": "Network",
  75. "Name": "host"
  76. },
  77. {
  78. "Type": "Network",
  79. "Name": "ipvlan"
  80. },
  81. {
  82. "Type": "Network",
  83. "Name": "macvlan"
  84. },
  85. {
  86. "Type": "Network",
  87. "Name": "null"
  88. },
  89. {
  90. "Type": "Network",
  91. "Name": "overlay"
  92. },
  93. {
  94. "Type": "Volume",
  95. "Name": "local"
  96. }
  97. ]
  98. },
  99. "TLSInfo": {
  100. "TrustRoot": "-----BEGIN CERTIFICATE-----\nMIIBazCCARCgAwIBAgIUY13k5tC6JLjbjGEPjuXUiJVQ6O0wCgYIKoZIzj0EAwIw\nEzERMA8GA1UEAxMIc3dhcm0tY2EwHhcNMjMxMTIzMDg0NzAwWhcNNDMxMTE4MDg0\nNzAwWjATMREwDwYDVQQDEwhzd2FybS1jYTBZMBMGByqGSM49AgEGCCqGSM49AwEH\nA0IABKXU197cjuB2Yul9m8TSDWJs7DySbr6W07TLCXspF+oklU3heaYgSXas3Y5h\nW5apP18B2cfK0cowIgaSAT0mEbGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMB\nAf8EBTADAQH/MB0GA1UdDgQWBBSjxbGtYF8NNoDaZcT98Jazqq3G6DAKBggqhkjO\nPQQDAgNJADBGAiEAmXzeGCNDSmjxdaGwfQD+XM4+sMIpFClxeBRUr+dTmZECIQDE\nZvih28ozoVDfCOexIWc9ggnem/tyTskK2yMvQyB0bg==\n-----END CERTIFICATE-----\n",
  101. "CertIssuerSubject": "MBMxETAPBgNVBAMTCHN3YXJtLWNh",
  102. "CertIssuerPublicKey": "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEpdTX3tyO4HZi6X2bxNINYmzsPJJuvpbTtMsJeykX6iSVTeF5piBJdqzdjmFblqk/XwHZx8rRyjAiBpIBPSYRsQ=="
  103. }
  104. },
  105. "Status": {
  106. "State": "ready",
  107. "Addr": "192.168.31.81"
  108. },
  109. "ManagerStatus": {
  110. "Leader": true,
  111. "Reachability": "reachable",
  112. "Addr": "192.168.31.81:2377"
  113. }
  114. }
  115. ]

 发现,角色是Manager

他是一个Leader

注意:

        可以有多个manager节点,但只能有一个是Leader

 4.查看工作节点的 token,worker加入集群

当又有一台服务器要加入这个worker集群时,可以通过docker swarm join-token worker来查看加入集群命令

  1. [root@manager_81 ~]# docker swarm join-token worker
  2. To add a worker to this swarm, run the following command:
  3. docker swarm join --token SWMTKN-1-6afkz1ub7m8q37cehxmjiirs6a0r25qt1hzf0no1c0xcny55qc-d3gtv0qcsuhivozbomp4d73ha 192.168.31.81:2377
  4. [root@manager_81 ~]#

 5.查看管理节点的 token , manager加入集群

当又有一台服务器要加入这个manager集群时,可以通过docker swarm join-token manager来查看加入集群命令,这里就不再演示

  1. [root@manager_81 ~]# docker swarm join-token manager
  2. To add a manager to this swarm, run the following command:
  3. docker swarm join --token SWMTKN-1-6afkz1ub7m8q37cehxmjiirs6a0r25qt1hzf0no1c0xcny55qc-2bogd7dp5r5wss6s3k255sq4v 192.168.31.81:2377
  4. [root@manager_81 ~]#

6.删除集群节点

当不需要某个工作节点时,可以在其节点上执行命令:docker swarm leave -f, 然后在管理节点上执行命令 docker node rm 节点ID -f 删除节点

  1. #管理节点上执行
  2. docker node rm 9xtzwe9h5w36snbheow3yzsy9 -f
  3. #工作节点上执行
  4. docker swarm leave -f

 7.节点的降级升级

管理节点可以降级成工作节点,工作节点也可以升级成管理节点
  1. #节点降级,由管理节点降级为工作节点
  2. docker node demote 节点ID
  3. #eg:节点降级
  4. docker node demote rpa61so05v8wcy5y9ohzn9tv1
  5. #节点升级,由工作节点升级为管理节点
  6. docker node promote 节点ID
  7. #eg:节点升级
  8. docker node promote rpa61so05v8wcy5y9ohzn9tv1

8.创建部署服务

以前是通过docker run来创建部署容器,但是该命令 docker run 容器启动,不具备扩所容,它只能在当前机器上运行,不能部署到多台服务器上,这时可以通过docker service来部署,因为docker service 服务,具有扩所容,滚动更新、回滚等功能,他会自动地部署到dokcer swarm对应的集群中(部署到多台服务器上),下面举个例子来说明

创建一个nginx镜像服务(需要在mananger上运行):

        

docker service create --name nginx01 --replicas 2 -p 80:80 nginx

        通过上面命令,创建一个服务nginx01,这个服务里面有两个nginx容器,这两个容器会随机部署到上面四个服务器上(通过算法实现)

        --name nginx服务名称

        --replicas 2 指定容器的副本,这里有2个,它会把nginx容器部署到集群这四台服务器上的随机两台上面,部署好后就可以在这四台服务器上任意一台访问nginx服务了            

  1. [root@manager_81 ~]# docker service create --name nginx01 --replicas 2 -p 80:80 nginx
  2. 797ddmq429mgst9y2su8ezywt
  3. overall progress: 0 out of 2 tasks
  4. 1/2: preparing [=================================> ]
  5. overall progress: 0 out of 2 tasks
  6. 1/2: preparing [=================================> ]
  7. overall progress: 2 out of 2 tasks
  8. 1/2: running [==================================================>]
  9. 2/2: running [==================================================>]
  10. verify: Service converged

9.查看所有服务详情

通过docker service ls查看创建的服务
  1. [root@manager_81 ~]#
  2. [root@manager_81 ~]# docker service ls
  3. ID NAME MODE REPLICAS IMAGE PORTS
  4. 797ddmq429mg nginx01 replicated 2/2 nginx:latest *:80->80/tcp

10.查看服务里面运行的容器

通过docker service ps 服务名 查看服务里运行的容器详情

  1. [root@manager_81 ~]# docker service ps nginx01
  2. ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS
  3. bypoyr3h2b8u nginx01.1 nginx:latest worker_140 Running Running 45 seconds ago
  4. ml9j2f9xx14u nginx01.2 nginx:latest manager_81 Running Running 3 minutes ago

发现nginx01服务里面运行了两个nginx服务,一个在worker_140,一个在manager_81上,可以在这两台机器上通过docker  ps查看

 

 

虽然nginx只部署到了四台机器上的两台中,但还是可以随机访问这四台机器,因为他们是一个集群,底层有一个负载均衡操作,通过ingress网卡处理: 

 

11.动态扩缩容 

  1. docker service update --replicas 10 nginx01
  2. #也可以使用
  3. docker service scale nginx01=10
  4. #通过这个命令就会把10个nginx容器随机部署到这四台服务器上(通过算法部署)

这里有一个需要注意的地方:

        当其中的某个容器挂掉后,swarm会自动地创建一个新的容器并随机分配到机器上(通过算法分析得出哪个机比较空闲,并分配容器),从而保证容器的个数可用,保证了负载均衡操作

 

 

12.删除服务

  1. #查看服务
  2. [root@manager_81 ~]# docker service ls
  3. ID NAME MODE REPLICAS IMAGE PORTS
  4. 797ddmq429mg nginx01 replicated 6/6 nginx:latest *:80->80/tcp
  5. #删除服务
  6. [root@manager_81 ~]# docker service rm nginx01
  7. nginx01
  8. #发现服务已被删除
  9. [root@manager_81 ~]#
  10. [root@manager_81 ~]# docker service ls
  11. ID NAME MODE REPLICAS IMAGE PORTS

13.负载均衡,随机调度功能

创建一个新的nginx服务,并映射html目录,暴露端口,扩容8个nginx容器,演示一下随机调度(负载均衡)的功能

docker service create --name nginx --replicas 8 -p 80:80 --mount type=bind,src=/root/wwwroot/html,dst=/usr/share/nginx/html nginx

 --mount: 相当于以前的-v(映射数据卷)

(1).在各个机器上创建/root/wwwroot/html目录

mkdir -p /root/wwwroot/html

(2).在html下创建index.html,并写入对应的内容

  1. vi index.html
  2. this is 192.168.31.xxx web

如下: 

(3).启动nginx服务 

说明集群没问题,通过上面访问显示,发现: 当访问81这台机器时,没有显示81这个上面的内容,这是因为在访问的时候,swarm通过ingress(特殊的overlay网络,具有负载均衡的功能 )网络算法,计算哪一台机器资源比较充足空闲,然后就指定到哪一台上面去访问,并不是到具体机器上,而是根据其算法计算得来的

三.docker swarm 部署借助docker-compose.yml部署集群

1.准备goweb项目镜像

参考 [Docker]九.Docker compose讲解

(1).配置Dockerfile

在/root/wwwroot/下新建Dockerfile,并写入以下内容

  1. FROM centos:centos7
  2. ADD ginGorm.tar.gz /root
  3. WORKDIR /root
  4. RUN chmod -R 777 ginGorm
  5. WORKDIR /root/ginGorm
  6. EXPOSE 8080
  7. ENTRYPOINT ["./goweb"]

(2).在要部署的服务器上面build一个gowebimg的镜像 创建nginx转发文件

也可以把build好的镜像发布到远程仓库:

        docker build -t docker.io/gowebimg:latest .

        docker push docker.io/gowebimg:latest

(3).所有主机上面下载镜像

docker pull gowebimg:latest

如果没有发布到docker上,则需把打包(docker save 镜像ID 镜像.tar)好的镜像复制到各个集群机器上,然后解压镜像(docker load -i 镜像包名, docker tag 镜像ID 镜像名:版本),下面展示各个机器上的镜:

2.准备docker-compose.yml文件

这里和[Docker]九.Docker compose讲解类似

  1. #指定docker-compose 版本
  2. version: "3"
  3. #services下就是容器的编写
  4. services:
  5. #容器,
  6. myMysql:
  7. #来自哪个镜像
  8. image: mysql
  9. #容器名,如果不指定,则使用myMysql这个容器默认名称
  10. container_name: myMysql
  11. #环境变量:配置用户名,密码等
  12. environment:
  13. MYSQL_ROOT_PASSWORD: 123456
  14. #restart: 表示容器挂掉后是否重启, always 一直重启
  15. restart: always
  16. #映射的端口
  17. ports:
  18. - 3306:3306
  19. #数据卷的挂载
  20. volumes:
  21. - /root/mysql/conf.d:/etc/mysql/conf.d
  22. - /root/mysql/data:/var/lib/mysql
  23. #配置goweb01项目容器
  24. goweb01:
  25. #build编译成镜像,可以使用上面的/root/wwwroot/Dockerfile里面的
  26. #build:
  27. # context: ./
  28. # dockerfile: Dockerfile
  29. #当然,也可以使用已经编译号的gowebimg镜像
  30. image: gowebimg:v1.0.1
  31. #container_name: goweb01
  32. restart: always
  33. #ports:
  34. # - 8080:8080
  35. deploy:
  36. replicas: 6 #副本数量
  37. resources: #资源
  38. limits: #配置cpu
  39. cpus: "0.5" # 设置该容器最多只能使用 50% 的 CPU
  40. memory: 500M # 设置该容器最多只能使用 500M内存
  41. restart_policy: #定义容器重启策略, 用于代替 restart 参数
  42. condition: on-failure #只有当容器内部应用程序出现问题才会重启
  43. #depends_on表示创建好myMysql这个容器后,再来创建goweb01这个容器
  44. depends_on:
  45. - myMysql
  46. #配置nginx容器
  47. nginx:
  48. image: nginx
  49. container_name: nginx
  50. restart: always
  51. ports:
  52. - 80:80
  53. depends_on:
  54. - goweb01
  55. volumes:
  56. - /root/nginx/conf.d/:/etc/nginx/conf.d
  57. deploy:
  58. replicas: 6 #副本数量
  59. resources: #资源
  60. limits: #配置cpu
  61. cpus: "0.5" # 设置该容器最多只能使用 50% 的 CPU
  62. memory: 500M # 设置该容器最多只能使用 500M内存
  63. restart_policy: #定义容器重启策略, 用于代替 restart 参数
  64. condition: on-failure #只有当容器内部应用程序出现问题才会重启

3.创建一个新的集群

在这之前需要在服务器上运行命令docker swarm leave -f 退出集群

(1).在manager_81上初始化集群

  1. root@manager_81 wwwroot]# docker swarm init --advertise-addr 192.168.31.81
  2. Swarm initialized: current node (7issgqc81r4xrl07y5qxedtpf) is now a manager.
  3. To add a worker to this swarm, run the following command:
  4. docker swarm join --token SWMTKN-1-1ytez4j3d9iccq7x92kw8dgx9v3q7w68ip24xavz5ec9zsoowc-577xpv4w5o73etzuhcql9bvd9 192.168.31.81:2377
  5. To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
  6. [root@manager_81 wwwroot

(2).然后在其他物理机上运行docker swarm join --token 加入集群

docker swarm join --token SWMTKN-1-1ytez4j3d9iccq7x92kw8dgx9v3q7w68ip24xavz5ec9zsoowc-577xpv4w5o73etzuhcql9bvd9 192.168.31.81:2377

 

 4.docker swarm +docker-compose 部署项目

注意:

        一般需要把mysql单独拿出来做成mysql集群,因为mysql有一个读写分离的操作,在这里就不处理,后续可以自己弄一下

        在使用docker-compose.yml之前,都建议把需要用到的镜像在每台机器上都下载下来,方便使用

下面部署: 

  1. #docker stack deploy --compose-file 为固定写法, gowebSwarm 为服务名称,可随意
  2. docker stack deploy --compose-file docker-compose.yml gowebSwarm

  1. #查看nginx服务部署详情
  2. [root@manager_81 wwwroot]# docker service ps gowebSwarm_nginx
  3. ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS
  4. ggsuom0uhaji gowebSwarm_nginx.1 nginx:latest manager_81 Running Running about a minute ago
  5. uls0crwvl45s gowebSwarm_nginx.4 nginx:latest worker_140 Running Failed 7 minutes ago "task: non-zero exit (1)"
  6. ggsuom0uhaji gowebSwarm_nginx.1 nginx:latest manager_81 Running Running about a minute ago
  7. uls0crwvl45s gowebSwarm_nginx.4 nginx:latest worker_140 Running Failed 7 minutes ago "task: non-zero exit (1)"

发现nginx部署在81和140上,查看

  1. #查看gowebimg部署详情
  2. [root@manager_81 wwwroot]# docker service ps gowebSwarm_goweb01
  3. ID NAME IMAGE NODE DESIRED STATE CURRENT STATE ERROR PORTS
  4. 8x0jlmxlai3g gowebSwarm_goweb01.1 gowebimg:v1.0.1 worker_241 Running Running 2 minutes ago
  5. dsndspg6ljae gowebSwarm_goweb01.2 gowebimg:v1.0.1 manager_81 Running Running 4 minutes ago
  6. 5fuq5kywo1aq gowebSwarm_goweb01.3 gowebimg:v1.0.1 worker_241 Running Running 2 minutes ago
  7. m6lpunm0lyi4 gowebSwarm_goweb01.4 gowebimg:v1.0.1 worker_140 Running Running 4 minutes ago

 发现goweb部署在241.81,140上,其中241上有两个:

在浏览器上访问,发现没问题,这样,一个nginx集群,goweb项目集群就搭建好了

下面还需在外部搭建一个nginx负载均衡的服务器,当外部访问这个nginx时,通过它转发到nginx集群,让集群去处理,这样才算是一个真正的负载均衡操作,达到的效果如下:

        当访问www.test.com时,随机访问的服务器为192.168.31.81,192.168.31.114,192.168.31.241,192.168.31.117这几台

5.配nginx负载均衡

(1).swarm 集群中的nginx配置

每台集群机器上的nginx配置文件(/root/nginx/conf.d/)

  1. upstream gowebtest{
  2. ip_hash;
  3. server goweb01:8080;
  4. }
  5. server {
  6. listen 80;
  7. server_name docker.test.com;
  8. location / {
  9. #设置主机头和客户端真实地址,以便服务器获取客户端真实IP
  10. #禁用缓存
  11. proxy_buffering off;
  12. #反向代理的地址
  13. proxy_pass http://gowebtest;
  14. }
  15. #error_page 404 /404.html;
  16. # redirect server error pages to the static page /50x.html
  17. #
  18. error_page 500 502 503 504 /50x.html;
  19. location = /50x.html {
  20. root html;
  21. }
  22. }

 (2).nginx主机服务器的配置

  1. upstream bakeaaa {
  2. ip_hash;
  3. server 192.168.31.81 weight=1;
  4. server 192.168.31.140 weight=1;
  5. server 192.168.31.117 weight=1;
  6. server 192.168.31.241 weight=1;
  7. }
  8. server {
  9. listen 80;
  10. server_name www.test.com;
  11. #charset koi8-r;
  12. #access_log /var/log/nginx/host.access.log main;
  13. location / {
  14. #设置主机头和客户端真实地址,以便服务器获取客户端真实 IP
  15. proxy_set_header Host $host;
  16. proxy_set_header X-Real-IP $remote_addr;
  17. proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  18. #nginx服务器与被代理服务连接超时时间,代理超时,超时后会请求其他server ip
  19. proxy_connect_timeout 1s;
  20. #禁用缓存
  21. proxy_buffering off;
  22. proxy_pass http://bakeaaa;
  23. }
  24. #error_page 404 /404.html;
  25. # redirect server error pages to the static page /50x.html
  26. #
  27. error_page 500 502 503 504 /50x.html;
  28. location = /50x.html {
  29. root /usr/share/nginx/html;
  30. }
  31. }

(3).查看nginx服务器转发的节点

server{}下添加如下两行配置:

  1. add_header backendCode $upstream_status;
  2. add_header BackendIP "$upstream_addr;" always;

(4).再新启一台服务器,作为nginx主机服务器

然后下载nginx

docker pull nginx

然后配置conf 

 (5).启动nginx容器

可以通过docker run或者docker service 启动一个nginx服务,这里目前就一台nginx对外暴露,可以用docker run启动

  1. [root@MiWiFi-R3L-srv conf.d]# docker images
  2. REPOSITORY TAG IMAGE ID CREATED SIZE
  3. nginx latest a6bd71f48f68 3 days ago 187MB
  4. [root@MiWiFi-R3L-srv conf.d]# docker run -it -d --name nginxweb -p 80:80 -v /root/nginx/conf.d/:/etc/nginx/conf.d nginx
  5. 30bbc795b79bc763205e0acfe111352efa96f2b91065a4923070786ccbdec8cd
  6. [root@MiWiFi-R3L-srv conf.d]# docker ps
  7. CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
  8. 30bbc795b79b nginx "/docker-entrypoint.…" About a minute ago Up About a minute 0.0.0.0:80->80/tcp, :::80->80/tcp nginxweb
  9. [root@MiWiFi-R3L-srv conf.d]#

 (6).配置hosts

(7).浏览器访问

 

 

这样就完成了一个负载均衡操作,对上面负载均衡的说明:

        当外部通过浏览器访问域名时,通过DNS域名转发,访问到了nginx主机(192.168.31.250)这台服务器,nginx服务器通过ip_hash转发给设置的几个server ip 服务器,其中接收到的服务器再通过底层的igress网络,使用算法计算得出哪一台服务器资源比较充足,就访问哪一台服务器

当然,上面的swarm集群目前只有一台manager结点,3台worker结点,一般在正式环境中,manager结点数在3~7台,worker结点也应该更多台,这样才能处理高并发

         

[上一节][Docker]九.Docker compose讲解

[下一节][Docker]十一.Docker Swarm集群raft算法,Docker Swarm Web管理工具 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/煮酒与君饮/article/detail/809201
推荐阅读
相关标签
  

闽ICP备14008679号