^-^
【go云原生】Docker项目部署
最近更新：2024-12-29   |   字数总计：3.1k   |   阅读估时：13分钟   |   阅读量：次
  1. Docker项目部署
    1. Docker Compose
      1. 一个简单计数案例
      2. Compose命令
      3. yml内容
      4. docker监控工具用compose组织
    2. Docker Swarm简介
    3. Swarm集群管理和节点管理
      1. 集群管理
      2. 节点管理
    4. Swarm服务部署
      1. 服务管理
      2. 带策略的服务部署
      3. 更新服务
      4. 回滚服务
    5. Swarm与Compose协作部署

Docker项目部署

Docker Compose

  • docker compose和dockerfile类似，是一个对容器编排的重现过程。但是它处理的是容器与容器的关系，无论在哪个宿主机我们都能使用docker compose重现这些容器的复杂过程。
  • 两个概念
    1. 服务service：一个应用的容器，实际上可以包含若干运行相同镜像的容器实例
    2. 项目project：由一组关联的应用容器组成的一个完整业务单元，在docker-compose.yml文件中定义
  • 安装
    1
    2
    3
    wget https://github.com/docker/compose/releases/download/v2.5.0/docker-compose-linux-x86_64
    cp -arf docker-compose-linux-x86_64 /usr/bin/docker-compose
    chmod +x /usr/bin/docker-compose
  • 卸载
    1
    rm /usr/bin/docker-compose

一个简单计数案例

1
2
3
mkdir composetest
cd composetest
vim app.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# python脚本
import time 
import redis
from flask import Flask
app = Flask(__name__)
cache = redis.Redis(host='redis', port=3679)
def get_hit_count():
    retries = 5
    while True:
        try:
            return cache.incr('hits')
        except redis.exceptions.ConnectionError as exc:
            if retries == 0:
                raise exc
            retries -= 1
            time.sleep(0.5)
@app.aoute('/')
def hello():
    count = get_hit_count()
    return 'Hello world! I have seen {} times.\n'.format(count)
1
2
3
4
5
6
7
8
9
10
11
12
13
vim requirements.txt
> flask
> redis
vim Dockerfile

FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
COPY requirements.txt requirements.txt 
RUN pip install -r requirements.txt 
COPY . .
CMD ["flask", "run"]
1
2
3
4
5
6
7
8
9
10
vim docker-compose.yml
# yaml配置
version: '3'
services: 
    web:
        build: . # 默认在当前目录找dockerfile去构建
        ports:
         - "5000:5000"
    redis:
        image: "redis:alpine"
  • compose定义了两个服务，一个web，一个redis，web使用我们dockerfile定义的镜像，redis使用一个公共的redis镜像
    1
    2
    docker-compose up # 启动docker compose
    curl http://localhost:5000

Compose命令

  1. build：重新构建服务的镜像，内部的服务要有dockerfile
    1
    docker-compose build web # 重新build并不会重新运行哦
  2. config: 对yml做语法检查
    1
    2
    docker-compose config
    docker-compose -f docker-compose-my.yml config # 假如我们的名字不是默认的docker-compose，需要指定名字
  3. down:停止通过up启动的容器
    1
    docker-compose down
  4. up：启动yml定义的服务容器们
    1
    docker-compose -p mycompose up -d # -p定义project的名字，-d是后台运行
  5. exec：进入到指定的service容器，它只认service名字，不认ps里面得到的创建的容器的名字
    1
    2
    docker-compose mycompose-redis-1 /bin/sh # 这样不行，不认容器名
    docker-compose -p mycompose redis /bin/sh # 若不指定project的名称，就会默认是当前目录的名字，所以需要写出自己定义的project名字
  6. images：查看使用的镜像
  7. kill：停止一个service
  8. ps：查看运行的容器
    1
    2
    docker-compose ps # 查看所有容器
    docker-compose ps web # 查看web service对应的容器
  9. push：推送服务依赖的镜像到仓库
  10. restart：重启service
    1
    docker-compose restart web # 重启服务
  11. start：启动指定服务
    1
    docker-compose start web
  12. stop：停止指定服务
    1
    docker-compost stop web

yml内容

  • https://docs.docker.com/compose/compose-file/
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    version: '3' 
    services: 
        web:
            build: .
            container_name: myapp # 指定容器名称
            ports:
             - "5000:5000"
            depends_on:
             - redis # 指定service依赖关系   
        redis:
            image: "redis:alpine"
            container_name: myredis
            expose:
              - 6380 # 对内的暴露端口
    1
    2
    3
    docker-compose start web # 此时会自动启动依赖的redis
    docker-compose stop # 先停止
    docker start myweb # 看看直接使用docker命令，那么就不会启动redis了，因为docker命令的对象是一个容器，他不知道依赖关系，而docker-compose的对象是整个project

docker监控工具用compose组织

1
2
3
mkdir dockermonitor
cd dockermonitor
vim nodeexporter.yml
  • 这里我们每一个工具一个compose配置，是为了可以分开设置分开启动，因为普罗米修斯的数据来自其他工具，而普罗米修斯并不需要每一个宿主机都启动，其他工具可能每个宿主机都需要启动；
  • nodeexporter.yml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    version: '3'
    services:
        node:
            image: "prom/node-exporter"
            volumns:
                - "/proc:/host/proc:ro"
                - "/sys:/host/sys:ro"
                - "/:/rootfs:ro"
                - "/etc/localtime:/etc/localtime:ro"
            environment:
                path.procfs: "/host/proc"
                path.sysfs: "/host/sys"
                collector.filesystem.ignored-mount-points: "^/(sys|proc|dev|host|etc)($$|/)"
            ports:
                - "9100:9100"
            container_name: "node-exporter"
  • cAdvisor.yml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    version: '3'
    services:
        cAdvisor:
            image: "google/cadvisor:latest"
        volumns:
            - "/:/rootfs:ro"
            - "/var/run:/var/run:ro"
            - "/sys:/sys:ro"
            - "/var/lib/docker/:/var/lib/docker:ro"
            - "/dev/disk/:/dev/disk:ro"
            - "/etc/localtime:/etc/localtime:ro"
        environment:
            privileged: true
        ports:
            - "8081:8080"
        container_name: "cAdvisor"
  • prometheus.yml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    version: '3'
    services:
        prometheus:
            image: "prom/prometheus"
            volumes:
                - "/opt/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml"
            ports:
                - "9090:9090"
            container_name: "prometheus"
  • grafana.yml
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    version: '3'
    services:
        grafana:
            image: "grafana/grafana"
            volumes:
                - "/etc/localtime:/etc/localtime:ro"
            environment:
                GF_SERVER_ROOT_URL: "http://192.168.239.142"
                GF_SECURITY_ADMIN_PASSWORD: "admin8888"
            ports:
                - "3000:3000"
            container_name: "localtime"
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    vim /opt/prometheus/prometheus.yml # 我们需要配置一下普罗米修斯
    gobal:
        scrape_interval: 20s
        evaluation_interval: 20s
    scrape_configs:
        - job_name: 'prometheus'
            static_configs:
            - targets: ['192.168.239.142:9090']
        - job_name: 'linux'
            static_configs:
            - targets: ['192.168.239.142:9100']
        - job_name: 'cadvisor'
            static_configs:
            - targets: ['192.168.239.142:8081']

    docker-compose -f cadvisor.yml -f nodeexporter.yml -f prometheus.yml -f grafana.yml up -d # 多配置文件启动容器
    # 我们每次docker-compose的时候会默认创建一个网络，这些service都会被添加到这个默认的网络中

Docker Swarm简介

  • 官方提供的跨节点的容器编排工具，只需要在单一的管理节点上从左，即可管理集群下的所有节点和容器；

  • 单对单的docker宿主机使用方式

  • 单对多的docker宿主机使用方式

  • Swarm概念

    1. 单引擎模式和swarm集群模式：
      1. 单引擎，未加入集群的docker server
      2. 加入任意swarm集群的docker server会自动切换到swarm集群模式
    2. manager（管理节点）、node（工作节点）
      1. manager：负责集群管理请求以及调度node进行具体工作
      2. node：接收调度
    3. raft共识算法，是实现分布式共识的一种算法，主要用来管理日志复制的一致性
      • swarm使用raft是为了确保集群中负责管理和调度任务的所有manager节点都存储相同的一致状态（注意是manager之间的一致性）；所以manager是高可用的，有一个manager down掉了，其他的manager可以负责恢复；
    4. Swarm管理节点高可用

  • 需要注意

    1. manager节点容错：设置为奇数个，可以减少脑裂情况，奇数节点可以保证投票有结果；不要部署太多manager节点，不然投票时间很长；

Swarm集群管理和节点管理

集群管理

  1. 创建集群
    1
    2
    3
    4
    docker swarm init
    # 成功后会提示给咱们加入的命令
    docker swarm join-token worker # 给我们一个join的特殊token，这个节点加入的时候作为worker
    docker swarm join-token manager # 给我们一个join的特殊token，这个节点加入的时候作为manager
  2. 加入集群
    1
    2
    docker swarm join --token SWMIKN-1-ljoinonoinigodfgnpoweirhgoierq 192.168.239.142:2377
    docker swarm info # 查看集群状态
  3. 离开集群
    1
    2
    docker swarm leave # worker 节点可以直接leave
    docker swarm -f leave # manager 节点需要前置leave，此时可能会有报错，且集群会变为不可用状态，因为集群的leader可能选举不出来的
  4. 强制创建集群
    1
    docker swarm --force-new-cluster init # 从上面集群不可用的状态重新强制创建一个集群
  5. 更新集群的参数
    1
    docker swarm update --autolock=false
  6. 锁定、解锁集群
  • 为的是防止旧的管理节点down后，再恢复后对集群带来安全隐患。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    docker swarm join-token manager 
    # 创建两个配用管理节点, 无论有多少个管理节点，只有一个是leader
    docker swarm join --token SWMIKN-1-ljoi98191915615165161561rq 192.168.239.142:2377
    docker swarm join --token SWMIKN-1-ljoi981919191251661565689fweafew 192.168.239.142:2377
    docker swarm update update --autolock=true  # 此时会给我们一个密钥，当有机器停机后就会被锁定，即使重新恢复了也需要这个密钥才能加入集群
    docker swarm unlock-key # 如果不记得密钥了，可以这样获取

    service docker stop # 停掉一个管理节点
    service docker start # 重启这个节点
    docker info # swarm是locked的状态
    docker swarm unlock # 输入密钥，加入集群
    docker node ls # 查看全部节点状态，发现已经恢复

节点管理

  1. 列出集群节点
    1
    docker node ls
  2. 升级或降级节点
    1
    2
    3
    4
    5
    docker node demote onoiaoiufopinqweongiphewqht
    docker node demote onoiaoiufopinqweongiphewqht # 不能再降级，已经是worker了
    docker node demote oinaoidutowihego19819891981 # 降级leader，会自动选择备选节点成为新的leader，和leave不同的是，这个节点不会离开集群

    docker node update onoiaoiufopinqweongiphewqht --role manager # 升级成管理，注意down的机器不能升级或降级
  3. 删除节点
    1
    2
    3
    docker node rm oinopiu91988198191 56198afdqwoeiufavnoe # 删除两个，只有down状态可以被删除
    # 注意down的节点被删除后，这个节点起来后，swarm状态仍然是在集群中的，所以不能直接使用swarm join加入，需要先使用leave
    docker node rm -f aefoinoinpuih191898 # 强制删除，只能删除worker节点，不能删除manager节点；
  4. 更新节点状态
    1
    2
    3
    docker node update --availability pause 56198afdqwoeiufavnoe # 挂起节点，新的应用不能部署到这个节点上，旧的不影响
    docker node update --availability drain oinopiu91988198191 # 排除节点，旧的应用会被调度到其他的节点
    docker node update --availability active 56198afdqwoeiufavnoe # 正常部署应用

Swarm服务部署

  • 准备应用
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    get clone https://gitee.com/nickdemo/helloworld.git
    cd helloworld
    git fetch origin

    # 准备两个版本的镜像
    git checkout 1.0.0
    docker build -f Dockfile -t hello:1.0.0 .

    git checkout 1.0.1
    docker build -f Dockfile -t hello:1.0.1 .

    docker tag hello:1.0.0 xlhmzch/hello:1.0.0
    docker push xlhmzch/hello:1.0.0

    docker tag hello:1.0.1 xlhmzch/hello:1.0.1
    docker push xlhmzch/hello:1.0.1

服务管理

  1. 创建一个服务
    1
    docker service create --name myhello --publish published=81,target=80 --replicas 3 xlhmzch/hello:1.0.0 # 在leader节点，创建服务
  2. 查看服务的任务（容器）
    1
    2
    docker service ps myhello
    docker service inspect myhello # 查看服务详情
  3. 查看全部的服务
    1
    docker service ls
  4. 访问服务
    1
    curl http:// localhost:81/ping # swarm为节点做了复杂均衡，所以任意节点都能访问到该端口的服务，包括没有部署该服务的节点；
  5. 查看服务日志
    1
    docker service logs lmoineointqo
  6. 伸缩服务
    1
    2
    3
    docker service scale myhello=20
    docker service ps myhello # 每个节点都分配了4个左右的副本
    docker service ls # 只有一个myhello服务，它有20个副本
  7. 和修改节点状态配合
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    docker node ls
    docker node update --availability pause 819a17dfwaefinoaidf # 挂起一个节点
    docker service scale myhello=40 # 伸缩服务
    docker service ps myhello # 看看挂起的节点分配的任务，没有再被分配新的副本
    docker service scale myhello=5 # 伸缩服务
    docker service ps myhello # 挂起的节点的任务也被缩容了，所以挂起后是可以缩容的，只是不能扩容
    docker service scale myhello=20 # 伸缩服务
    # 换到另外的节点
    docker node update --availability drain 819a17dfwaefinoa884 # 排除一个节点
    docker ps # 当前节点的任务都被调度走了
  8. 高可用测试
    1
    2
    3
    4
    5
    docker node ls # 三个manager
    docker service ps myhello # 20个副本被分配
    service docker stop # 停掉一个leader
    docker node ls # 两个manager，进行了重新选举
    docker service ps myhello # 仍然是20个副本，有些被重新分配了
  9. 当swarm共识算法失效后，无法选出leader，此时会发生什么？
    • 3个manager down掉2个，此时swarm的管理会失效，docker node ls等命令都会超时
    • 但是服务是正常的，curl http://localhost:81 仍然可以访问
    • 无法进行调度、伸缩和管理了
  • 集群、节点、服务、容器、任务、compose概念层次
    1. 集群（管理节点）
      1. 节点
        1. 容器
        2. 容器
      2. 节点
        1. 容器
        2. 容器
      3. 节点
    2. 服务（定义副本，被分配到节点）
      1. 副本（任务）=部署后> 容器
      2. 副本（任务）=部署后> 容器
      3. 副本（任务）=部署后> 容器
    3. compose管理（管理容器/服务之间的关系）
      1. 服务
        1. 副本。。。
      2. 服务

带策略的服务部署

1
2
3
4
5
6
7
8
9
10
11
12
13
docker service create --name myhello1 
    --publish published=82,target=80 --replicas 20 # 端口、副本
    --update-parallelism 2 # 每次更新2个容器
    --update-delay 5s # 容器更新的延迟，结合上一个，就是每次更新2个容器，每5s更新一次
    --update-failure-action continue # 更新失败后继续
    --rollback-parallelism 2 # 每次rollback两个
    --rollback-monitor 10s # rollback后10s内监控是否报错
    --rollback-max-failure-ratio 0.2 # 回滚的失败概率只允许20%
    xlhmzch/hello:1.0.0

docker service ps myhello1
docker service inspect --pretty myhello1
docker service update --update-delay 5s # 更新策略配置

更新服务

1
docker service update --image xlhmzch/hello:1.0.1 myhello1 # 看更新策略是否是每次更新2个，之后等5s

回滚服务

1
docker service update --rollback myhello1 # 手动回滚

Swarm与Compose协作部署

  • swarm单独有一个stack模块用来使用compose部署服务
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    version: "3.7"
    services:
        myhello2:
            image: xlhmzch/hello:1.0.0
            ports:
                - "83:80"
            depends_on:
                - redis
            deploy: # 在这里设置副本和更新策略
                mode: replicated
                replicas: 20
                endpoint_mode: vip
                rollback_config:
                    parallelism: 2
                    delay: 10s
                    monitor: 10s
                    max_failure_ratio: 0.2
                update_config:
                    parallelism: 2
                    delay: 5s
                    failure_action: continue
        redis:
            image: redis:alpine
            deploy:
                mode: replicated
                replicas: 6
                endpoint_mode: dnsrr
                labels:
                    description: "This redis service label."
                resources:
                    limits:
                        cpus: '0.50'
                        memory: 50M
                    reservations:
                        cpus: '0.25'
                        memory: 20M
                restart_policy:
                    condition: on-failure
                    delay: 5s
                    max_attempts: 3
                    windows: 120s
  • 部署
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    mkdir deploy
    cd deploy
    vim docker-compose.yml
    > :set_parse # 防止粘贴缩进有问题
    > ctrl+v
    docker stack deploy -c docker-compose.yml mystack # 取个stack的名字，启动一个新的stack
    docker stack ls # 查看所有stack
    docker stack ps mystack # 查看所有部署的容器
    docker stack services mystack # 查看stack里所有的服务
    vim docker-compose.yml
    # 将镜像换成1.0.1
    docker stack deploy -c docker-compose.yml mystack # 因为已经存在了这个stack，所以这里是更新服务的操作
2024-12-27 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go云原生】持续集成与持续部署 下一篇：【go云原生】Docker镜像
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题