Docker 实战操作之docker-compose容器编排管理(六)

# 安装docker时顺便安装docker-compose
yum install -y yum-utils device-mapper-persistent-data lvm2
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
yum makecache fast
# 安装docker时直接安装docker-compose
yum -y install docker-ce  docker-compose
systemctl enable docker
systemctl start docker

#安装docker以及python/python3
# centos使用命令 yum -y install python-pip/python3-pip安装pip
pip install -U docker-compose  或者pip3 install -U docker-compose

# 下载二进制包: https://github.com/docker/compose/releases 
# 下载后直接放到执行路径即可
#下载docker-compose-Linux-x86_64
cp docker-compose-Linux-x86_64 /usr/bin/docker-compose
# 必须授权否则无法执行
chmod +x /usr/bin/docker-compose

docker-compose --version

docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]

Define and run multi-container applications with Docker.
Usage:
  docker-compose [-f <arg>...] [options] [COMMAND] [ARGS...]
  docker-compose -h|--help
Options:
  -f, --file FILE             Specify an alternate compose file (default: docker-compose.yml)
  -p, --project-name NAME     Specify an alternate project name (default: directory name)
  --verbose                   Show more output
  --no-ansi                   Do not print ANSI control characters
  -v, --version               Print version and exit
  -H, --host HOST             Daemon socket to connect to
  --tls                       Use TLS; implied by --tlsverify
  --tlscacert CA_PATH         Trust certs signed only by this CA
  --tlscert CLIENT_CERT_PATH  Path to TLS certificate file
  --tlskey TLS_KEY_PATH       Path to TLS key file
  --tlsverify                 Use TLS and verify the remote
  --skip-hostname-check       Don't check the daemon's hostname against the name specified
                              in the client certificate (for example if your docker host
                              is an IP address)
  --project-directory PATH    Specify an alternate working directory
                              (default: the path of the Compose file)
Commands:
  build              Build or rebuild services
  bundle             Generate a Docker bundle from the Compose file
  config             Validate and view the Compose file
  create             Create services
  down               Stop and remove containers, networks, images, and volumes
  events             Receive real time events from containers
  exec               Execute a command in a running container
  help               Get help on a command
  images             List images
  kill               Kill containers
  logs               View output from containers
  pause              Pause services
  port               Print the public port for a port binding
  ps                 List containers
  pull               Pull service images
  push               Push service images
  restart            Restart services
  rm                 Remove stopped containers
  run                Run a one-off command
  scale              Set number of containers for a service
  start              Start services
  stop               Stop services
  top                Display the running processes
  unpause            Unpause services
  up                 Create and start containers
  version            Show the Docker-Compose version information

-f --file FILE指定Compose模板文件，默认为docker-compose.yml
-p --project-name NAME 指定项目名称，默认使用当前所在目录为项目名
--verbose  输出更多调试信息
-v，-version 打印版本并退出
--log-level LEVEL 定义日志等级(DEBUG, INFO, WARNING, ERROR, CRITICAL)

docker-compose up [options] [--scale SERVICE=NUM...] [SERVICE...]
--scale：指定服务运行的容器个数（如果服务有对外的端口就不能指定多个容器，因为端口已经被占用）   
Eg：docker-compose up -d --scale web=1 --scale redis=2
选项包括：
-d 在后台运行服务容器
-no-color 不是有颜色来区分不同的服务的控制输出
-no-deps 不启动服务所链接的容器
--force-recreate 强制重新创建容器，不能与-no-recreate同时使用
–no-recreate 如果容器已经存在，则不重新创建，不能与–force-recreate同时使用
–no-build 不自动构建缺失的服务镜像
–build 在启动容器前构建服务镜像
–abort-on-container-exit 停止所有容器，如果任何一个容器被停止，不能与-d同时使用
-t, –timeout TIMEOUT 停止容器时候的超时（默认为10秒）
–remove-orphans 删除服务中没有在compose文件中定义的容器

docker-compose  ps [options] [SERVICE...]
列出project所有运行容器（容器名 = 目录名_service_index  index表示容器序数，从1开始）

docker-compose stop [options] [SERVICE...]
-t, –timeout TIMEOUT 停止容器时候的超时（默认为10秒）
docker-compose stop
停止正在运行的容器，可以通过docker-compose start 再次启动
（可选）serviceName：表示停止某一个service

docker-compose -h   或者 docker-compose --help
查看帮助

docker-compose down [options]
停止和删除容器、网络、卷、镜像。
选项包括：
–rmi type，删除镜像，类型必须是：all，删除compose文件中定义的所有镜像；local，删除镜像名为空的镜像
-v, –volumes，删除已经在compose文件中定义的和匿名的附在容器上的数据卷
–remove-orphans，删除服务中没有在compose中定义的容器
docker-compose down
停用移除所有容器以及网络相关
（相当于 stop + rm ）：停止并移除整个project的所有services

docker-compose logs [options] [SERVICE...]
查看服务容器的输出。默认情况下，docker-compose将对不同的服务输出使用不同的颜色来区分。可以通过–no-color来关闭颜色。
docker-compose logs
查看服务容器的日志输出 
-f 跟踪日志输出，实时输出日志
查看服务内所有容器日志输出，
加上serviceName表示输出某一个service的日志

docker-compose build [options] [--build-arg key=val...] [SERVICE...]
构建（重新构建）项目中的服务容器。
选项包括：
–compress 通过gzip压缩构建上下环境
–force-rm 删除构建过程中的临时容器
–no-cache 构建镜像过程中不使用缓存
–pull 始终尝试通过拉取操作来获取更新版本的镜像
-m, –memory MEM为构建的容器设置内存大小
–build-arg key=val为服务设置build-time变量
服务容器一旦构建后，将会带上一个标记名。可以随时在项目目录下运行docker-compose build来重新构建服务
构建/重新构建所有镜像
当某个service的Dockerfile改变时，即镜像发生改变需要重新生成时，如果仅仅是docker-compose.yml改变，只需要up重新启动project即可

docker-compose pull [options] [SERVICE...]
拉取服务依赖的镜像。
选项包括：
–ignore-pull-failures，忽略拉取镜像过程中的错误
–parallel，多个镜像同时拉取
–quiet，拉取镜像过程中不打印进度信息
docker-compose pull
拉取服务依赖的镜像

docker-compose restart [options] [SERVICE...]
重启项目中的服务。
选项包括：
-t, –timeout TIMEOUT，指定重启前停止容器的超时（默认为10秒）
docker-compose restart
重启项目中的服务

docker-compose rm [options] [SERVICE...]
删除所有（停止状态的）服务容器。
选项包括：
–f, –force，强制直接删除，包括非停止状态的容器
-v，删除容器所挂载的数据卷
docker-compose rm
删除所有（停止状态的）服务容器。推荐先执行docker-compose stop命令来停止容器。

docker-compose start [SERVICE...]
docker-compose start
启动已存在但停止的所有service

docker-compose run [options] [-v VOLUME...] [-p PORT...] [-e KEY=VAL...] SERVICE [COMMAND] [ARGS...]
在某个服务上运行命令
docker-compose run ubuntu ping www.baidu.com
在指定容器上执行一个ping命令。

docker-compose scale web=3 db=2
设置指定服务运行的容器个数。通过service=num的参数来设置数量

docker-compose pause [SERVICE...]
暂停一个服务容器

docker-compose kill [options] [SERVICE...]
通过发送SIGKILL信号来强制停止服务容器。 
支持通过-s参数来指定发送的信号，例如通过如下指令发送SIGINT信号：
docker-compose kill -s SIGINT

docker-compose config [options]
验证并查看compose文件配置。
选项包括：
–resolve-image-digests 将镜像标签标记为摘要
-q, –quiet 只验证配置，不输出。 当配置正确时，不输出任何内容，当文件配置错误，输出错误信息
–services 打印服务名，一行一个
–volumes 打印数据卷名，一行一个

docker-compose create [options] [SERVICE...]
为服务创建容器。
选项包括：
–force-recreate：重新创建容器，即使配置和镜像没有改变，不兼容–no-recreate参数
–no-recreate：如果容器已经存在，不需要重新创建，不兼容–force-recreate参数
–no-build：不创建镜像，即使缺失
–build：创建容器前　　，生成镜像

docker-compose exec [options] SERVICE COMMAND [ARGS...]
选项包括：
-d 分离模式，后台运行命令。
–privileged 获取特权。
–user USER 指定运行的用户。
-T 禁用分配TTY，默认docker-compose exec分配TTY。
–index=index，当一个服务拥有多个容器时，可通过该参数登陆到该服务下的任何服务，例如：docker-compose exec –index=1 web /bin/bash ，web服务中包含多个容器

docker-compose port [options] SERVICE PRIVATE_PORT
显示某个容器端口所映射的公共端口。
选项包括：
–protocol=proto，指定端口协议，TCP（默认值）或者UDP
–index=index，如果同意服务存在多个容器，指定命令对象容器的序号（默认为1）

docker-compose push [options] [SERVICE...]
推送服务依的镜像。
选项包括：
–ignore-push-failures 忽略推送镜像过程中的错误

docker-compose stop [options] [SERVICE...]
停止运行的容器

docker-compose unpause [SERVICE...]
恢复处于暂停状态中的服务。

# Compose和Docker兼容性：
    # Compose 文件格式有3个版本,分别为1, 2.x 和 3.x
    # 目前主流的为 3.x 其支持 docker 1.13.0 及其以上的版本
# 常用参数：
    version           # 指定 compose 文件的版本
    services          # 定义所有的 service 信息, services 下面的第一级别的 key 既是一个 service 的名称
        build                 # 指定包含构建上下文的路径, 或作为一个对象，该对象具有 context 和指定的 dockerfile 文件以及 args 参数值
            context               # context: 指定 Dockerfile 文件所在的路径
            dockerfile            # dockerfile: 指定 context 指定的目录下面的 Dockerfile 的名称(默认为 Dockerfile)
            args                  # args: Dockerfile 在 build 过程中需要的参数 (等同于 docker container build --build-arg 的作用)
            cache_from            # v3.2中新增的参数, 指定缓存的镜像列表 (等同于 docker container build --cache_from 的作用)
            labels                # v3.3中新增的参数, 设置镜像的元数据 (等同于 docker container build --labels 的作用)
            shm_size              # v3.5中新增的参数, 设置容器 /dev/shm 分区的大小 (等同于 docker container build --shm-size 的作用)
        command               # 覆盖容器启动后默认执行的命令, 支持 shell 格式和 [] 格式
        configs               # 不知道怎么用
        cgroup_parent         # 不知道怎么用
        container_name        # 指定容器的名称 (等同于 docker run --name 的作用)
        credential_spec       # 不知道怎么用
        deploy                # v3 版本以上, 指定与部署和运行服务相关的配置, deploy 部分是 docker stack 使用的, docker stack 依赖 docker swarm
            endpoint_mode         # v3.3 版本中新增的功能, 指定服务暴露的方式
                vip                   # Docker 为该服务分配了一个虚拟 IP(VIP), 作为客户端的访问服务的地址
                dnsrr                 # DNS轮询, Docker 为该服务设置 DNS 条目, 使得服务名称的 DNS 查询返回一个 IP 地址列表, 客户端直接访问其中的一个地址
            labels                # 指定服务的标签，这些标签仅在服务上设置
            mode                  # 指定 deploy 的模式
                global                # 每个集群节点都只有一个容器
                replicated            # 用户可以指定集群中容器的数量(默认)
            placement             # 不知道怎么用
            replicas              # deploy 的 mode 为 replicated 时, 指定容器副本的数量
            resources             # 资源限制
                limits                # 设置容器的资源限制
                    cpus: "0.5"           # 设置该容器最多只能使用 50% 的 CPU 
                    memory: 50M           # 设置该容器最多只能使用 50M 的内存空间 
                reservations          # 设置为容器预留的系统资源(随时可用)
                    cpus: "0.2"           # 为该容器保留 20% 的 CPU
                    memory: 20M           # 为该容器保留 20M 的内存空间
            restart_policy        # 定义容器重启策略, 用于代替 restart 参数
                condition             # 定义容器重启策略(接受三个参数)
                    none                  # 不尝试重启
                    on-failure            # 只有当容器内部应用程序出现问题才会重启
                    any                   # 无论如何都会尝试重启(默认)
                delay                 # 尝试重启的间隔时间(默认为 0s)
                max_attempts          # 尝试重启次数(默认一直尝试重启)
                window                # 检查重启是否成功之前的等待时间(即如果容器启动了, 隔多少秒之后去检测容器是否正常, 默认 0s)
            update_config         # 用于配置滚动更新配置
                parallelism           # 一次性更新的容器数量
                delay                 # 更新一组容器之间的间隔时间
                failure_action        # 定义更新失败的策略
                    continue              # 继续更新
                    rollback              # 回滚更新
                    pause                 # 暂停更新(默认)
                monitor               # 每次更新后的持续时间以监视更新是否失败(单位: ns|us|ms|s|m|h) (默认为0)
                max_failure_ratio     # 回滚期间容忍的失败率(默认值为0)
                order                 # v3.4 版本中新增的参数, 回滚期间的操作顺序
                    stop-first            #旧任务在启动新任务之前停止(默认)
                    start-first           #首先启动新任务, 并且正在运行的任务暂时重叠
            rollback_config       # v3.7 版本中新增的参数, 用于定义在 update_config 更新失败的回滚策略
                parallelism           # 一次回滚的容器数, 如果设置为0, 则所有容器同时回滚
                delay                 # 每个组回滚之间的时间间隔(默认为0)
                failure_action        # 定义回滚失败的策略
                    continue              # 继续回滚
                    pause                 # 暂停回滚
                monitor               # 每次回滚任务后的持续时间以监视失败(单位: ns|us|ms|s|m|h) (默认为0)
                max_failure_ratio     # 回滚期间容忍的失败率(默认值0)
                order                 # 回滚期间的操作顺序
                    stop-first            # 旧任务在启动新任务之前停止(默认)
                    start-first           # 首先启动新任务, 并且正在运行的任务暂时重叠
                支持 docker-compose up 和 docker-compose run 但不支持 docker stack deploy 的子选项
                security_opt  container_name  devices  tmpfs  stop_signal  links    cgroup_parent
                network_mode  external_links  restart  build  userns_mode  sysctls
        devices               # 指定设备映射列表 (等同于 docker run --device 的作用)
        depends_on            # 定义容器启动顺序 (此选项解决了容器之间的依赖关系， 此选项在 v3 版本中 使用 swarm 部署时将忽略该选项)
                docker-compose up 以依赖顺序启动服务，下面例子中 redis 和 db 服务在 web 启动前启动
                默认情况下使用 docker-compose up web 这样的方式启动 web 服务时，也会启动 redis 和 db 两个服务，因为在配置文件中定义了依赖关系
                version: '3'
                services:
                    web:
                        build: .
                        depends_on:
                            - redis  
                    redis:
                        image: redis
                        image: postgres                             
        dns                   # 设置 DNS 地址(等同于 docker run --dns 的作用)
        dns_search            # 设置 DNS 搜索域(等同于 docker run --dns-search 的作用)
        tmpfs                 # v2 版本以上, 挂载目录到容器中, 作为容器的临时文件系统(等同于 docker run --tmpfs 的作用, 在使用 swarm 部署时将忽略该选项)
        entrypoint            # 覆盖容器的默认 entrypoint 指令 (等同于 docker run --entrypoint 的作用)
        env_file              # 从指定文件中读取变量设置为容器中的环境变量, 可以是单个值或者一个文件列表, 如果多个文件中的变量重名则后面的变量覆盖前面的变量, environment 的值覆盖 env_file 的值
            文件格式：
                RACK_ENV=development 
        environment           # 设置环境变量， environment 的值可以覆盖 env_file 的值 (等同于 docker run --env 的作用)
        expose                # 暴露端口, 但是不能和宿主机建立映射关系, 类似于 Dockerfile 的 EXPOSE 指令
        external_links        # 连接不在 docker-compose.yml 中定义的容器或者不在 compose 管理的容器(docker run 启动的容器, 在 v3 版本中使用 swarm 部署时将忽略该选项)
        extra_hosts           # 添加 host 记录到容器中的 /etc/hosts 中 (等同于 docker run --add-host 的作用)
        healthcheck           # v2.1 以上版本, 定义容器健康状态检查, 类似于 Dockerfile 的 HEALTHCHECK 指令
            test                  # 检查容器检查状态的命令, 该选项必须是一个字符串或者列表, 第一项必须是 NONE, CMD 或 CMD-SHELL, 如果其是一个字符串则相当于 CMD-SHELL 加该字符串
                NONE                  # 禁用容器的健康状态检测
                CMD                   # test: ["CMD", "curl", "-f", "http://localhost"]
                CMD-SHELL             # test: ["CMD-SHELL", "curl -f http://localhost || exit 1"] 或者　test: curl -f https://localhost || exit 1
            interval: 1m30s       # 每次检查之间的间隔时间
            timeout: 10s          # 运行命令的超时时间
            retries: 3            # 重试次数
            start_period: 40s     # v3.4 以上新增的选项, 定义容器启动时间间隔
            disable: true         # true 或 false, 表示是否禁用健康状态检测和　test: NONE 相同
        image                 # 指定 docker 镜像, 可以是远程仓库镜像、本地镜像
        init                  # v3.7 中新增的参数, true 或 false 表示是否在容器中运行一个 init, 它接收信号并传递给进程
        isolation             # 隔离容器技术, 在 Linux 中仅支持 default 值
        labels                # 使用 Docker 标签将元数据添加到容器, 与 Dockerfile 中的 LABELS 类似
        links                 # 链接到其它服务中的容器, 该选项是 docker 历史遗留的选项, 目前已被用户自定义网络名称空间取代, 最终有可能被废弃 (在使用 swarm 部署时将忽略该选项)
        logging               # 设置容器日志服务
            driver                # 指定日志记录驱动程序, 默认 json-file (等同于 docker run --log-driver 的作用)
            options               # 指定日志的相关参数 (等同于 docker run --log-opt 的作用)
                max-size              # 设置单个日志文件的大小, 当到达这个值后会进行日志滚动操作
                max-file              # 日志文件保留的数量
        network_mode          # 指定网络模式 (等同于 docker run --net 的作用, 在使用 swarm 部署时将忽略该选项)         
        networks              # 将容器加入指定网络 (等同于 docker network connect 的作用), networks 可以位于 compose 文件顶级键和 services 键的二级键
            aliases               # 同一网络上的容器可以使用服务名称或别名连接到其中一个服务的容器
            ipv4_address      # IP V4 格式
            ipv6_address      # IP V6 格式
                version: '3.7'
                services: 
                    test: 
                        image: nginx:1.14-alpine
                        container_name: mynginx
                        command: ifconfig
                        networks: 
                            app_net:                                # 调用下面 networks 定义的 app_net 网络
                              ipv4_address: 172.16.0.1
                networks:
                    app_net:
                        driver: bridge
                        ipam:
                            driver: default
                            config:
                                - subnet: 172.16.0.0/16
        pid: 'host'           # 共享宿主机的 进程空间(PID)
        ports                 # 建立宿主机和容器之间的端口映射关系, ports 支持两种语法格式
            SHORT 语法格式示例:
                - "3000"                            # 暴露容器的 3000 端口, 宿主机的端口由 docker 随机映射一个没有被占用的端口
                - "3000-3005"                       # 暴露容器的 3000 到 3005 端口, 宿主机的端口由 docker 随机映射没有被占用的端口
                - "8000:8000"                       # 容器的 8000 端口和宿主机的 8000 端口建立映射关系
                - "9090-9091:8080-8081"
                - "127.0.0.1:8001:8001"             # 指定映射宿主机的指定地址的
                - "127.0.0.1:5000-5010:5000-5010"   
                - "6060:6060/udp"                   # 指定协议
            LONG 语法格式示例:(v3.2 新增的语法格式)
                ports:
                    - target: 80                    # 容器端口
                      published: 8080               # 宿主机端口
                      protocol: tcp                 # 协议类型
                      mode: host                    # host 在每个节点上发布主机端口,  ingress 对于群模式端口进行负载均衡
        secrets               # 不知道怎么用
        security_opt          # 为每个容器覆盖默认的标签 (在使用 swarm 部署时将忽略该选项)
        stop_grace_period     # 指定在发送了 SIGTERM 信号之后, 容器等待多少秒之后退出(默认 10s)
        stop_signal           # 指定停止容器发送的信号 (默认为 SIGTERM 相当于 kill PID; SIGKILL 相当于 kill -9 PID; 在使用 swarm 部署时将忽略该选项)
        sysctls               # 设置容器中的内核参数 (在使用 swarm 部署时将忽略该选项)
        ulimits               # 设置容器的 limit
        userns_mode           # 如果Docker守护程序配置了用户名称空间, 则禁用此服务的用户名称空间 (在使用 swarm 部署时将忽略该选项)
        volumes               # 定义容器和宿主机的卷映射关系, 其和 networks 一样可以位于 services 键的二级键和 compose 顶级键, 如果需要跨服务间使用则在顶级键定义, 在 services 中引用
            SHORT 语法格式示例:
                volumes:
                    - /var/lib/mysql                # 映射容器内的 /var/lib/mysql 到宿主机的一个随机目录中
                    - /opt/data:/var/lib/mysql      # 映射容器内的 /var/lib/mysql 到宿主机的 /opt/data
                    - ./cache:/tmp/cache            # 映射容器内的 /var/lib/mysql 到宿主机 compose 文件所在的位置
                    - ~/configs:/etc/configs/:ro    # 映射容器宿主机的目录到容器中去, 权限只读
                    - datavolume:/var/lib/mysql     # datavolume 为 volumes 顶级键定义的目录, 在此处直接调用
            LONG 语法格式示例:(v3.2 新增的语法格式)
                version: "3.2"
                services:
                    web:
                        image: nginx:alpine
                        ports:
                            - "80:80"
                        volumes:
                            - type: volume                  # mount 的类型, 必须是 bind、volume 或 tmpfs
                                source: mydata              # 宿主机目录
                                target: /data               # 容器目录
                                volume:                     # 配置额外的选项, 其 key 必须和 type 的值相同
                                    nocopy: true                # volume 额外的选项, 在创建卷时禁用从容器复制数据
                            - type: bind                    # volume 模式只指定容器路径即可, 宿主机路径随机生成; bind 需要指定容器和数据机的映射路径
                                source: ./static
                                target: /opt/app/static
                                read_only: true             # 设置文件系统为只读文件系统
                volumes:
                    mydata:                                 # 定义在 volume, 可在所有服务中调用
        restart               # 定义容器重启策略(在使用 swarm 部署时将忽略该选项, 在 swarm 使用 restart_policy 代替 restart)
            no                    # 禁止自动重启容器(默认)
            always                # 无论如何容器都会重启
            on-failure            # 当出现 on-failure 报错时, 容器重新启动
        其他选项：
            domainname, hostname, ipc, mac_address, privileged, read_only, shm_size, stdin_open, tty, user, working_dir
            上面这些选项都只接受单个值和 docker run 的对应参数类似
        对于值为时间的可接受的值：
            2.5s
            1m30s
            2h32m
            5h34m56s
            时间单位: us, ms, s, m， h
        对于值为大小的可接受的值：
            1024kb
            2048k
            单位: b, k, m, g 或者 kb, mb, gb
    networks          # 定义 networks 信息
        driver                # 指定网络模式, 大多数情况下, 它 bridge 于单个主机和 overlay Swarm 上
            bridge                # Docker 默认使用 bridge 连接单个主机上的网络
            overlay               # overlay 驱动程序创建一个跨多个节点命名的网络
            host                  # 共享主机网络名称空间(等同于 docker run --net=host)
            none                  # 等同于 docker run --net=none
        driver_opts           # v3.2以上版本, 传递给驱动程序的参数, 这些参数取决于驱动程序
        attachable            # driver 为 overlay 时使用, 如果设置为 true 则除了服务之外，独立容器也可以附加到该网络; 如果独立容器连接到该网络，则它可以与其他 Docker 守护进程连接到的该网络的服务和独立容器进行通信
        ipam                  # 自定义 IPAM 配置. 这是一个具有多个属性的对象, 每个属性都是可选的
            driver                # IPAM 驱动程序, bridge 或者 default
            config                # 配置项
                subnet                # CIDR格式的子网，表示该网络的网段
        external              # 外部网络, 如果设置为 true 则 docker-compose up 不会尝试创建它, 如果它不存在则引发错误
        name                  # v3.5 以上版本, 为此网络设置名称
文件格式示例：
    version: "3"
    services:
      redis:
        image: redis:alpine
        ports:
          - "6379"
        networks:
          frontend:
            ipv4_address: 172.19.0.2
        deploy:
          replicas: 2
          update_config:
            parallelism: 2
            delay: 10s
          restart_policy:
            condition: on-failure
        image: postgres:9.4
        volumes:
          - db-data:/var/lib/postgresql/data
        networks:
          backend:
            ipv4_address: 172.19.0.3
        deploy:
          placement:
            constraints: [node.role == manager]
    # 定义网络        
    networks:
      frontend:
        ipam:
          config:
          - subnet: 172.19.0.0/16
            gateway: 172.19.0.1
      backend:
        ipam:
          config:
          - subnet: 172.19.0.0/16
            gateway: 172.19.0.1

image: centos:7.9.2009
image: orchardup/postgresql
image: a4bc65fd

build: /path/to/build/dir

command: bundle exec thin -p 3000

links:
 - db:database
 - redis

172.17.2.186  db
172.17.2.186  database
172.17.2.187  redis

external_links:
 - redis_1
 - project_db_1:mysql
 - project_db_1:postgresql

ports:
 - "3000"
 - "8000:8000"
 - "49100:22"
 - "127.0.0.1:8001:8001"

expose:
 - "3000"
 - "8000"

volumes:
 - /var/lib/mysql
 - cache/:/tmp/cache
 - ~/configs:/etc/configs/:ro

volumes_from:
 - service_name
 - container_name

environment:
  RACK_ENV: development
  SESSION_SECRET:
environment:
  - RACK_ENV=development
  - SESSION_SECRET

env_file: .env
env_file:
  - ./common.env
  - ./apps/web.env
  - /opt/secrets.env

# common.env: Set Rails/Rack environment
RACK_ENV=development

# common.yml
webapp:
  build: ./webapp
  environment:
    - DEBUG=false
    - SEND_EMAILS=false

# development.yml
  extends:
    file: common.yml
    service: webapp
  ports:
    - "8000:8000"
  links:
  environment:
    - DEBUG=true
  image: postgres

net: "bridge"
net: "none"
net: "container:[name or id]"
net: "host"

pid: "host"

dns: 8.8.8.8
  - 8.8.8.8
  - 9.9.9.9

cap_add:
  - ALL
cap_drop:
  - NET_ADMIN
  - SYS_ADMIN

dns_search: example.com
dns_search:
  - domain1.example.com
  - domain2.example.com

cpu_shares: 73
working_dir: /code
entrypoint: /code/entrypoint.sh
user: postgresql
hostname: foo
domainname: foo.com
mem_limit: 1000000000
privileged: true
restart: always
stdin_open: true
tty: true

version: '3'
services:
  web1:
    container_name: "web1"
    image: nginx:1.21.0
    ports:
    - "8081:80"
    networks:
      - dev
  web2:
    image: nginx:1.21.0
    container_name: "web2"
    ports:
    - "8082:80"
    networks:
      - dev
      - pro
  web3:
    image: nginx:1.21.0
    container_name: "web3" 
    ports: 
    - "8083:80"  
    networks: 
      - pro 
networks:
  dev:
    driver: bridge
  pro:
    driver: bridge

version: "3.5"
services:
  web1:
    build: 
      context: ./myweb        # 配置构建image的Dockerfile文件位置
      dockerfile: Dockerfile-web1  # 指定dockerfile文件名
    container_name: nginx1    # 容器名必须唯一
    ports:
    - "8081:80"
  web2:
    build:
      context: ./myweb
      dockerfile: Dockerfile-web2
    container_name: nginx2
    ports:
    - "8082:80"
  web3:
    build:
      context: ./myweb
      dockerfile: Dockerfile-web3
    container_name: nginx3
    ports:
    - "8083:80"

FROM nginx:1.21.0
RUN  rm -rf /usr/share/nginx/html/index.html && echo "this is web1 page" > /usr/share/nginx/html/index.html
EXPOSE 80
STOPSIGNAL SIGQUIT
WORKDIR /
CMD ["nginx","-g","daemon off;"]

FROM nginx:1.21.0
RUN  rm -rf /usr/share/nginx/html/index.html && echo "this is web2 page" > /usr/share/nginx/html/index.html
EXPOSE 80
STOPSIGNAL SIGQUIT
WORKDIR /
CMD ["nginx","-g","daemon off;"]

FROM nginx:1.21.0
RUN  rm -rf /usr/share/nginx/html/index.html && echo "this is web3 page" > /usr/share/nginx/html/index.html
EXPOSE 80
STOPSIGNAL SIGQUIT
WORKDIR /
CMD ["nginx","-g","daemon off;"]

version: '3.5'
services:
      zoo1:
          image: zookeeper:3.6
          restart: always
          container_name: zoo1
          hostname: zookeeper1
          ports:
            - 2181:2181
          volumes:
            - /home/zk/zoo1/data:/data
            - /home/zk/zoo1/datalog:/datalog
          environment:
            ZOO_MY_ID: 1
            ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
            ZOO_AUTOPURGE_PURGEINTERVAL: 1
          networks:
            myzookeeper:
              ipv4_address: 172.19.0.3
      zoo2:
          image: zookeeper:3.6
          restart: always
          container_name: zoo2
          hostname: zookeeper2
          ports:
            - 2182:2181
          volumes:
            - /home/zk/zoo2/data:/data
            - /home/zk/zoo2/datalog:/datalog
          environment:
             ZOO_MY_ID: 2
             ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
             ZOO_AUTOPURGE_PURGEINTERVAL: 1
          networks:
            myzookeeper:
              ipv4_address: 172.19.0.4
      zoo3:
          image: zookeeper:3.6
          restart: always
          container_name: zoo3
          hostname: zookeeper3
          ports:
            - 2183:2181
          volumes:
            - /home/zk/zoo3/data:/dada
            - /home/zk/zoo3/datalog:/datalog
          environment:
            ZOO_MY_ID: 3
            ZOO_SERVERS: server.1=zoo1:2888:3888;2181 server.2=zoo2:2888:3888;2181 server.3=zoo3:2888:3888;2181
            ZOO_AUTOPURGE_PURGEINTERVAL: 1
          networks:
            myzookeeper:
              ipv4_address: 172.19.0.5
networks:
  myzookeeper:
      ipam:
        config:
        - subnet: 172.19.0.0/16
          gateway: 172.19.0.2

version: "3"
services:
  weba:
    image: nginx:1.21.0
    container_name: weba
    hostname: weba
    restart: always
    expose:
    volumes:
    - "./weba/:/usr/share/nginx/html/"
  webb:
    image: nginx:1.21.0
    container_name: webb
    hostname: webb
    restart: always
    expose:
    volumes:
    - "./webb/:/usr/share/nginx/html/"
  webc:
    image: nginx:1.21.0
    container_name: webc
    hostname: webc
    restart: always
    expose:
    volumes:
    - "./webc/:/usr/share/nginx/html/"
  haproxy:
    image: haproxy:2.3
    volumes:
    - ./ha:/haproxy-override
    - ./ha/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
    links:
    - weba
    - webb
    - webc
    ports:
    - "80:80"
    - "70:70"
    expose:
    - "80"
    - "70"
global
  log 127.0.0.1 local0
  log 127.0.0.1 local1 notice
defaults
  log global
  mode http
  option httplog
  option dontlognull
  timeout connect 5000ms
  timeout client 50000ms
  timeout server 50000ms
listen stats 
    bind 0.0.0.0:70
    stats refresh 5s 
    stats enable
    stats uri /
frontend balancer
    bind 0.0.0.0:80
    mode http
    default_backend web_backends
backend web_backends
    mode http
    option forwardfor
    balance roundrobin
    server weba weba:80 check
    server webb webb:80 check
    server webc webc:80 check
    option httpchk GET /
    http-check expect status 200

version: '3.5'
services:
  mysql:
    image: mysql:5.7.33
    container_name: mysql
    restart: always
    ports:
    - 3306:3306
    environment:
       TZ: Asia/Shanghai
       MYSQL_ROOT_PASSWORD: 123456
       MYSQL_ROOT_HOST: "%"
    command:
      --character-set-server=utf8mb4
      --collation-server=utf8mb4_general_ci
      --explicit_defaults_for_timestamp=true
      --lower_case_table_names=1
      --max_allowed_packet=128M
      --sql-mode="STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION,NO_ZERO_DATE,NO_ZERO_IN_DATE,ERROR_FOR_DIVISION_BY_ZERO"
    volumes:
    - "/data/mysql-data:/var/lib/mysql"

version: '3.5'                                    # 配置版本号
services:                                   
    mysql-server:                                 # 服务名称        
      image: mysql:5.7.33                         # 使用的镜像及版本        
      volumes:              
        - /data/db_data:/var/lib/mysql            # 文件挂载路径
      restart: always                             # 重启方式
      environment:              
        MYSQL_ROOT_PASSWORD: 123456
        MYSQL_DATABASE: zabbix
        MYSQL_USER: zabbix
        MYSQL_PASSWORD: 123456
      command: --character-set-server=utf8          #命令参数
    zabbix-java-gateway:
      image: zabbix/zabbix-java-gateway:latest
      restart: always
    zabbix-server:
      depends_on:        # 配置当前服务依赖的服务
        - mysql-server
        - zabbix-java-gateway
      image: zabbix/zabbix-server-mysql:latest
      ports: 
        - "10051:10051"
      restart: always
      environment:
        DB_SERVER_HOST: mysql-server
        MYSQL_DATABASE: zabbix
        MYSQL_USER: zabbix
        MYSQL_PASSWORD: 123456
        MYSQL_ROOT_PASSWORD: 123456
        ZBX_JAVAGATEWAY: zabbix-java-gateway
    zabbix-web-nginx-mysql:
      depends_on:
        - mysql-server
        - zabbix-server
      image: zabbix/zabbix-web-nginx-mysql:latest
      ports: 
        - "80:8080"
      restart: always
      environment:
        DB_SERVER_HOST: mysql-server
        MYSQL_DATABASE: zabbix
        MYSQL_USER: zabbix
        MYSQL_PASSWORD: 123456
        MYSQL_ROOT_PASSWORD: 123456

version: '3.5'
services:
  gitlab:
    image: gitlab/gitlab-ce:10.8.4-ce.0
    container_name: gitlab
    hostname: mygitlab
    ports:
      - '80:80'
      - '443:443'
      - '2222:22'
    volumes:
      - /data/gitlab_docker/data:/var/opt/gitlab
      - /data/gitlab_docker/logs:/var/log/gitlab
      - /data/gitlab_docker/etc:/etc/gitlab
    restart: always
    networks:
    - gitlabnet
    environment:
      GITLAB_OMNIBUS_CONFIG: |
        # 配置此参数，可以解决在创建项目时，gitlab以容器ID为域名的问题
        external_url 'http://10.0.0.14'
        gitlab_rails['time_zone'] = 'Asia/Shanghai'
        gitlab_rails['gitlab_shell_ssh_port'] = 2222    # 注意这里的端口2222不是容器中的SSH端口，而是主机映射的端口
        gitlab_rails['manage_backup_path'] = true
        # 备份路径
        gitlab_rails['backup_path'] = "/var/opt/gitlab/backups"
        # 备份文件权限
        gitlab_rails['backup_archive_permissions'] = 0644
        # 备份保留时间 604800 = 7天
        gitlab_rails['backup_keep_time'] = 604800
        #gitlab_rails['smtp_enable'] = true
        #gitlab_rails['smtp_address'] = "smtp.163.com"
        #gitlab_rails['smtp_password'] = "授权码"
        #gitlab_rails['smtp_domain'] = "163.com"
        #gitlab_rails['smtp_authentication'] = "login"
        #gitlab_rails['smtp_enable_starttls_auto'] = true
        #gitlab_rails['smtp_tls'] = true
        #gitlab_rails['gitlab_email_from'] = 'xxxxxx@163.com'
        #nginx['enable'] = true
        #nginx['client_max_body_size'] = '10240m'
        #nginx['redirect_http_to_https'] = true
        #nginx['ssl_certificate'] = "/etc/gitlab/ssl/fullchain.cer"
        #nginx['ssl_certificate_key'] = "/etc/gitlab/ssl/git.xxxx.com.key"
        #nginx['ssl_ciphers'] = "ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-GCM-SHA256"
        #nginx['ssl_prefer_server_ciphers'] = "on"
        #nginx['ssl_protocols'] = "TLSv1.1 TLSv1.2"
        #nginx['ssl_session_cache'] = "builtin:1000  shared:SSL:10m"
        #nginx['listen_addresses'] = ["0.0.0.0"]
        #nginx['http2_enabled'] = true
        #postgresql['max_worker_processes'] = 8
        #postgresql['shared_buffers'] = "256MB"
networks:
  gitlabnet:

version: '3.5'
services:
  redis:
    image: redis:6.2.1
    container_name: redis6.2.1
    restart: always
    ports:
      - 6379:6379
    networks:
      - mynetwork
    volumes:
      - ./redis.conf:/usr/local/etc/redis/redis.conf:rw
      - ./data:/data:rw
    command:
      /bin/bash -c "redis-server /usr/local/etc/redis/redis.conf "
networks:
  mynetwork:
    external: true

version: '3.5'
services:
  master:
    image: redis:6.2.1
    container_name: redis-master
    ports:
      - 6379:6379
  slave1:
    image: redis:6.2.1
    container_name: redis-slave-1
    ports:
    - 6380:6379
    command: redis-server --slaveof redis-master 6379
  slave2:
    image: redis:6.2.1
    container_name: redis-slave-2
    ports:
    - 6381:6379
    command: redis-server --slaveof redis-master 6379

#!/usr/bin/python
#authors: 7d
import sys
import BaseHTTPServer
from SimpleHTTPServer import SimpleHTTPRequestHandler
import socket
import fcntl
import struct
import pickle
from datetime import datetime
from collections import OrderedDict
class HandlerClass(SimpleHTTPRequestHandler):
    def get_ip_address(self,ifname):
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        return socket.inet_ntoa(fcntl.ioctl(
            s.fileno(),
            0x8915,  # SIOCGIFADDR
            struct.pack('256s', ifname[:15])
        )[20:24])
    def log_message(self, format, *args):
        if len(args) < 3 or "200" not in args[1]:
            return
        try:
            request = pickle.load(open("pickle_data.txt","r"))
        except:
            request=OrderedDict()
        time_now = datetime.now()
        ts = time_now.strftime('%Y-%m-%d %H:%M:%S')
        server = self.get_ip_address('eth0')
        host=self.address_string()
        addr_pair = (host,server)
        if addr_pair not in request:
            request[addr_pair]=[1,ts]
        else:
            num = request[addr_pair][0]+1
            del request[addr_pair]
            request[addr_pair]=[num,ts]
        file=open("index.html", "w")
        file.write("<!DOCTYPE html> <html> <body><center><h1><font color=\"blue\" face=\"Georgia, Arial\" size=8><em>HA</em></font> Webpage Visit Results</h1></center>");
        for pair in request:
            if pair[0] == host:
                guest = "LOCAL: "+pair[0]
            else:
                guest = pair[0]
            if (time_now-datetime.strptime(request[pair][1],'%Y-%m-%d %H:%M:%S')).seconds < 3:
                file.write("<p style=\"font-size:150%\" >#"+ str(request[pair][1]) +": <font color=\"red\">"+str(request[pair][0])+ "</font> requests " + "from &lt<font color=\"blue\">"+guest+"</font>&gt to WebServer &lt<font color=\"blue\">"+pair[1]+"</font>&gt</p>")
            else:
                file.write("<p style=\"font-size:150%\" >#"+ str(request[pair][1]) +": <font color=\"maroon\">"+str(request[pair][0])+ "</font> requests " + "from &lt<font color=\"navy\">"+guest+"</font>&gt to WebServer &lt<font color=\"navy\">"+pair[1]+"</font>&gt</p>")
        file.write("</body> </html>");
        file.close()
        pickle.dump(request,open("pickle_data.txt","w"))
if __name__ == '__main__':
    try:
        ServerClass  = BaseHTTPServer.HTTPServer
        Protocol     = "HTTP/1.0"
        addr = len(sys.argv) < 2 and "0.0.0.0" or sys.argv[1]
        port = len(sys.argv) < 3 and 80 or int(sys.argv[2])
        HandlerClass.protocol_version = Protocol
        httpd = ServerClass((addr, port), HandlerClass)
        sa = httpd.socket.getsockname()
        print "Serving HTTP on", sa[0], "port", sa[1], "..."
        httpd.serve_forever()
    except:
        exit()

touch index.html

FROM python:2.7
WORKDIR /code
ADD . /code
EXPOSE 80
CMD python index.py

global
  log 127.0.0.1 local0
  log 127.0.0.1 local1 notice
defaults
  log global
  mode http
  option httplog
  option dontlognull
  timeout connect 5000ms
  timeout client 50000ms
  timeout server 50000ms
listen stats 
    bind 0.0.0.0:70
    stats refresh 5s 
    stats enable
    stats uri /
frontend balancer
    bind 0.0.0.0:80
    mode http
    default_backend web_backends
backend web_backends
    mode http
    option forwardfor
    balance roundrobin
    server weba weba:80 check
    server webb webb:80 check
    server webc webc:80 check
    option httpchk GET /
    http-check expect status 200

version: "3"
services:
  weba:
    build: ./web
    expose:
  webb:
    build: ./web
    expose:
  webc:
    build: ./web
    expose:
  haproxy:
    image: haproxy:2.3
    volumes:
    - ./haproxy:/haproxy-override
    - ./haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
    links:
    - weba
    - webb
    - webc
    ports:
    - "80:80"
    - "70:70"
    expose:
    - "80"
    - "70"

compose-haproxy-web
├── docker-compose.yml
├── haproxy
│   └── haproxy.cfg
└── web
    ├── Dockerfile
    ├── index.html
    └── index.py

[root@localhost compose-haproxy-web]# docker-compose up
Creating composehaproxyweb_weba_1    ... done
Creating composehaproxyweb_webb_1    ... done
Creating composehaproxyweb_webc_1    ... done
Creating composehaproxyweb_webc_1    ... 
Creating composehaproxyweb_haproxy_1 ... done
Attaching to composehaproxyweb_webc_1, composehaproxyweb_webb_1, composehaproxyweb_weba_1, composehaproxyweb_haproxy_1
haproxy_1  | [NOTICE]   (1) : New worker #1 (9) forked

-v /etc/localtime:/etc/localtime:ro

# 适用于基础OS镜像
# ubuntu
apt-get update
apt-get install -y net-tools vim
# centos