[Docker]九.Docker compose讲解

docker-compose 是 docker 官方的一个开源项目，可以实现对 docker 容器集群的快速编排,

docker-compose 通过一个 配置文件 来管理多个 Docker 容器,在配置文件中，所有的容器通过

services 来定义，然后使用 docker-compose脚本 来 启动，停止和重启 容器,使用 docker-compose 可以对项目进行 快速部署

一.Docker命令部署Nginx + Go Web+Mysql项目

golang 部署见 [Docker]六.Docker自动部署nodejs以及golang项目

1.Docker部署mysql数据库

(1).docker images查看是否存在mysql镜像

docker images查看是否存在mysql镜像不存在则通过docker pull mysql 下载

#查看镜像
[root@MiWiFi-R3L-srv ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
mycentos     v1        4ba38cf3943b   18 hours ago   434MB

#发现没有mysql镜像,下载
[root@MiWiFi-R3L-srv ~]# docker pull mysql
Using default tag: latest
latest: Pulling from library/mysql
8e0176adc18c: Pull complete 
2d2c52718f65: Pull complete 
d88d03ce139b: Pull complete 
4a7d7f11aa1e: Pull complete 
ce5949193e4c: Pull complete 
f7f024dfb329: Pull complete 
5fc3c840facc: Pull complete 
509068e49488: Pull complete 
cbc847bab598: Pull complete 
942bef62a146: Pull complete 
Digest: sha256:1773f3c7aa9522f0014d0ad2bbdaf597ea3b1643c64c8ccc2123c64afd8b82b1
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest

#已经下载好了mysql镜像 
[root@MiWiFi-R3L-srv ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
mycentos     v1        4ba38cf3943b   18 hours ago   434MB
mysql        latest    a3b6608898d6   4 weeks ago    596MB

(2).创建mysql配置文件

(3).通过mysql镜像启动一个容器

docker run --name myMysql -p 3306:3306 -v /root/mysql/conf.d:/etc/mysql/conf.d -v /root/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql

#通过mysql镜像,启动mysql容器
[root@MiWiFi-R3L-srv mysql]# docker run --name myMysql -p 3306:3306 -v /root/mysql/conf.d:/etc/mysql/conf.d -v /root/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql
14aca92308e4816d26fbf4187635888421b4b8be141a5e65bef35614e0d2b921

#查看是否启动mysql容器
[root@MiWiFi-R3L-srv mysql]# docker ps
CONTAINER ID   IMAGE     COMMAND                  CREATED              STATUS          PORTS                                                  NAMES
14aca92308e4   mysql     "docker-entrypoint.s…"   About a minute ago   Up 58 seconds   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   myMysql

(4).通过可视化工具连接mysql

(5).修改项目app.ini文件,连接容器mysql

通过上面布置,说明了goweb项目能够操作容器的mysql了,接下来就需要把本地的goweb项目部署到远程服务器上,也就是部署到远程服务器的容器上

2.打包Go Web项目,发布到远程容器中

(1).打包Go Web项目

参考[Docker]六.Docker自动部署nodejs以及golang项目

进入项目文件,执行下面语句,生成linux可执行文件:

        set CGO_ENABLED=0

        set GOOS=linux

        set GOARCH=amd64

        go build -o goweb main.go

下一步需要把可执行文件,conf,static,templates,go.mod等静态文件发布到远程

(2).发布项目到远程

这里以发布到虚拟机(192.168.31.81)为例,发布到/root/wwwroot下

(3).浏览器访问

接下来就需要把Go Web项目部署到容器中去

(4).启动一个centos的docker容器,部署Go Web项目

docker run -it -d --name 容器名 -p 本地端口 : 容器端口 -v 本地文件夹:容器文件夹 --link 容器名 : 镜像名镜像名

-v 映射数据卷(映射目录)
--link 容器名:镜像名表示配置别名,这样可以通过容器名来访问容器

docker run -it -d --name goweb01 --link myMysql:mysql -p 8080:8080 -v /root/wwwroot/:/root centos
比如上面的 goweb01就可以通过myMysql来访问数据库

启动一个centos容器:

#启动一个centos容器,并指定名称以及开启端口,映射数据卷等
[root@MiWiFi-R3L-srv ~]# docker run -it -d --name goweb01 --link myMysql:mysql -p 8080:8080 -v /root/wwwroot/:/root 4ba38cf3943b
ecec9c9dd9627dfd9b2008a257f72668908d88b49967aa248a728ad11bf412ef
[root@MiWiFi-R3L-srv ~]# 

#发现已经启动了goweb01
[root@MiWiFi-R3L-srv ~]# docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                                  NAMES
ecec9c9dd962   4ba38cf3943b   "/bin/sh -c /bin/bash"   7 seconds ago   Up 2 seconds   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp              goweb01
14aca92308e4   mysql          "docker-entrypoint.s…"   4 hours ago     Up 4 hours     0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   myMysql

进入容器,然后设置项目后台运行,然后curl访问:

命令:nohup ./goweb & 项目可以在后台运行

#查看运行的容器
[root@MiWiFi-R3L-srv ~]# docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED         STATUS         PORTS                                                  NAMES
ecec9c9dd962   4ba38cf3943b   "/bin/sh -c /bin/bash"   7 seconds ago   Up 2 seconds   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp              goweb01
14aca92308e4   mysql          "docker-entrypoint.s…"   4 hours ago     Up 4 hours     0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   myMysql

#进入goweb01容器
[root@MiWiFi-R3L-srv ~]# docker exec -it ecec9c9dd962 /bin/bash
bash-4.2# cd /root/
bash-4.2# ls
ginGorm

#设置权限
bash-4.2# chmod -R 777 ginGorm/
bash-4.2# cd ginGorm/
bash-4.2# ls
conf  go.mod  go.sum  goweb  static  templates

#启动项目,后台运行
bash-4.2# nohup ./goweb &     
[1] 27
bash-4.2# nohup: ignoring input and appending output to 'nohup.out'

#curl访问,没问题
bash-4.2# curl 127.0.0.1:8080

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="/static/css/base.css">
</head>
<body>

    <h1>我是一个GoWeb+Mysql的项目</h1>
    <br>
    
    我是一个msg
    <br>
    2023-07-19 17:40:18

    <br>
    <h3>这里可以显示客户端ip:</h3>

    
      <p>  172.17.0.3</p>
    

</body>
</html>
bash-4.2#

在浏览器中访问:

这里讲一下上面的--link,在启动容器后,进入容器cat /etc/hosts可以看到:

[root@MiWiFi-R3L-srv ~]# docker exec -it ecec9c9dd962 /bin/bash
bash-4.2# cat /etc/hosts
127.0.0.1       localhost
::1     localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

#这里就是--link配置后生成的mysql,有一个myMysql,这个是一个别名,项目就可以通过这个别名来访问数据库
172.17.0.2      mysql 14aca92308e4 myMysql
172.17.0.3      ecec9c9dd962
bash-4.2# 

#可以ping通
bash-4.2# ping myMysql
PING mysql (172.17.0.2) 56(84) bytes of data.
64 bytes from mysql (172.17.0.2): icmp_seq=1 ttl=64 time=0.127 ms
64 bytes from mysql (172.17.0.2): icmp_seq=2 ttl=64 time=0.130 ms
^C
--- mysql ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1011ms

可以修改app.ini数据库配置,直接使用别名访问:

3.docker 部署nginx转发服务

当需要通过域名而不是ip访问项目时,就需要配置nginx了

(1).创建nginx配置目录

(2).生成nginx.conf文件

upstream backendtest {
        ip_hash;
        server goweb01:8080;
}
server {
    listen 80;
    server_name docker.test.com;
    location / {
        #设置主机头和客户端真实地址，以便服务器获取客户端真实IP
        #禁用缓存
        proxy_buffering off;
        #反向代理的地址
        proxy_pass http://backendtest;
    }
#error_page 404 /404.html;
# redirect server error pages to the static page /50x.html
#
error_page 500 502 503 504 /50x.html;
        location = /50x.html {
        root html;
    }
}

(3).下载nginx镜像,并启动一个nginx容器

docker run -it -d --name 容器名 -p 本地端口:容器端口 --link 容器名:镜像名 -v 数据卷:容器数据卷镜像名

docker pull nginx

docker run -it -d --name nginxweb -p 80:80 --link goweb01:centos -v
 /root/nginx/conf.d/:/etc/nginx/conf.d nginx

#启动一个nignx容器,并开启端口,映射数据卷
[root@MiWiFi-R3L-srv conf.d]# docker run -it -d --name nginxweb -p 80:80 --link goweb01:centos -v /root/nginx/conf.d/:/etc/nginx/conf.d nginx
a0f45848b9ed30b10e178e66d1bf58478f5719f017a0bb736b8b9fc7f0de0000

#查看启动的容器: 已经启动了mysql,goweb01,nginx容器
[root@MiWiFi-R3L-srv conf.d]# docker ps
CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                                                  NAMES
a0f45848b9ed   nginx          "/docker-entrypoint.…"   13 seconds ago   Up 5 seconds    0.0.0.0:80->80/tcp, :::80->80/tcp                      nginxweb
ecec9c9dd962   4ba38cf3943b   "/bin/sh -c /bin/bash"   34 minutes ago   Up 34 minutes   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp              goweb01
14aca92308e4   mysql          "docker-entrypoint.s…"   4 hours ago      Up 4 hours      0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   myMysql

(4).配置本地hosts,设置域名

二.Dockerfile部署Nginx+ Go Web+mysql项目

Dockerfile 部署 Nginx+ Go Web+mysql 项目和docker部署项目类似,这里在另一台服务器(192.168.31.117)上演示

1.Docker部署mysql数据库

该步骤和上面步骤mysql数据库步骤一致,这里就不讲解了

2.打包Go Web项目,发布到远程容器中

(1).打包Go Web项目,并发布到远程服务端/root/wwwroot/下

该步骤和上面步骤一致,结果如下:

(2).新建Dockerfile,编写生成镜像所需

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

FROM centos:centos7
ADD ginGorm.tar.gz /root
WORKDIR /root
RUN chmod -R 777 ginGorm
WORKDIR /root/ginGorm
EXPOSE 8080
ENTRYPOINT ["./goweb"]

(3).打包项目

(4).执行build,生成镜像

[root@MiWiFi-R3L-srv wwwroot]# docker build -t gowebimg:v1.0.1 .
[+] Building 19.4s (10/10) FINISHED                                                                                    docker:default
 => [internal] load build definition from Dockerfile                                                                             0.1s
 => => transferring dockerfile: 242B                                                                                             0.0s
 => [internal] load .dockerignore                                                                                                0.1s
 => => transferring context: 2B                                                                                                  0.0s
 => [internal] load metadata for docker.io/library/centos:centos7                                                                1.1s
 => [internal] load build context                                                                                                0.6s
 => => transferring context: 8.94MB                                                                                              0.6s
 => CACHED [1/5] FROM docker.io/library/centos:centos7@sha256:be65f488b7764ad3638f236b7b515b3678369a5124c47b8d32916d6487418ea4   0.0s
 => [2/5] ADD /ginGorm.tar.gz /root                                                                                              0.5s
 => [3/5] WORKDIR /root                                                                                                          0.0s
 => [4/5] RUN chmod -R 777 ginGorm                                                                                               9.8s
 => [5/5] WORKDIR /root/ginGorm                                                                                                  0.5s
 => exporting to image                                                                                                           5.8s
 => => exporting layers                                                                                                          4.6s
 => => writing image sha256:be3c1ee42ce234885fe50ff06de2e7dcca79e8c4dfa01183f462accaa38ba871                                     0.8s
 => => naming to docker.io/library/gowebimg:v1.0.1                                                                               0.4s
[root@MiWiFi-R3L-srv wwwroot]# 
[root@MiWiFi-R3L-srv wwwroot]# ll
total 8736
-rw-r--r--. 1 root root     143 Nov 22 04:04 Dockerfile
drwxrwxrwx. 5 root root      90 Nov 22 03:49 ginGorm
-rw-r--r--. 1 root root 8940056 Nov 22 04:00 ginGorm.tar.gz

#查看生成的gowebimg镜像
[root@MiWiFi-R3L-srv wwwroot]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED              SIZE
gowebimg     v1.0.1    be3c1ee42ce2   About a minute ago   237MB
mycentos     v1        38ea0d55bfbe   24 hours ago         434MB
mysql        latest    a3b6608898d6   4 weeks ago          596MB
[root@MiWiFi-R3L-srv wwwroot]#

(4).通过生成的gowebimg镜像启动容器

docker run -it -d --name goweb01 -p 8080:8080 --link myMysql:mysql gowebimg:v1.0.1

(5).直接进入容器访问测试

#查看gowebimg容器生成的镜像
[root@MiWiFi-R3L-srv wwwroot]# docker ps
CONTAINER ID   IMAGE             COMMAND                  CREATED             STATUS             PORTS                                                  NAMES
b89c74fa36d0   gowebimg:v1.0.1   "./goweb"                13 seconds ago      Up 5 seconds       0.0.0.0:8080->8080/tcp, :::8080->8080/tcp              goweb01
1eba1d7316e1   mysql             "docker-entrypoint.s…"   About an hour ago   Up About an hour   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   myMysql

#进入goweb01容器
[root@MiWiFi-R3L-srv wwwroot]# docker exec -it b8 /bin/bash

#curl测试访问,发现没问题
[root@b89c74fa36d0 ginGorm]# curl 127.0.0.1:8080

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="/static/css/base.css">
</head>
<body>

    <h1>我是一个GoWeb+Mysql的项目</h1>
    <br>
    
    我是一个msg
    <br>
    2023-07-19 17:40:18

    <br>
    <h3>这里可以显示客户端ip:</h3>

    
      <p>  172.17.0.3</p>
    

</body>
</html>
[root@b89c74fa36d0 ginGorm]#

上面就是通过Dockerfile生成一个项目镜像,然后启动容器访问项目,这样的话,goweb项目就部署好了,下来就来配置nginx了

3.docker 部署nginx转发服务

这里和上面一致,就不再讲解了,部署完后,修改hosts文件就可以通过浏览器访问了

好了,通过Dockerfile部署项目就完成了,通过上面的部署,发现:要部署mysql,nginx,goweb项目三个docker,那有没有一种方式可以通过一个文件一次性地部署几个docker呢,下面讲解docker compose

三.通过docker compose 部署项目

Docker-Compose 是 Docker 官方的开源项目，可以实现对 Docker 容器集群的快速编排,使用 docker compose可以对项目进行快速部署

1.安装docker-compose

见linux环境,centos8下 docker及docker compose安装教程

2.docker-compose 部署nginx+mysql+goWeb项目

(1).编写docker-compose.yml文件

要使用docker-compose 部署项目,就需要一个docker-compose.yml文件,内容如下:

#指定docker-compose 版本
version: "3"

#services下就是容器的编写
services:
    #容器,
    myMysql:
        #来自哪个镜像
        image: mysql
        #容器名,如果不指定,则使用myMysql这个容器默认名称
        container_name: myMysql
        #环境变量:配置用户名,密码等
        environment:
            MYSQL_ROOT_PASSWORD: 123456
        #restart:  表示容器挂掉后是否重启, always 一直重启
        restart: always
        #映射的端口
        ports:
            - 3306:3306
        #数据卷的挂载
        volumes:
            - /root/mysql/conf.d:/etc/mysql/conf.d
            - /root/mysql/data:/var/lib/mysql
    #配置goweb01项目容器
    goweb01:
        #build编译成镜像,可以使用上面的/root/wwwroot/Dockerfile里面的
        build:
            context: ./
            dockerfile: Dockerfile
        #当然,也可以使用已经编译号的gowebimg镜像
        #image: gowebimg

        container_name: goweb01
        restart: always
        ports:
            - 8080:8080
        #depends_on表示创建好myMysql这个容器后,再来创建goweb01这个容器
        depends_on:
            - myMysql
    #配置nginx容器
    nginx:
        image: nginx
        container_name: nginx
        restart: always
        ports:
            - 80:80
        depends_on:
            - goweb01
        volumes:
            - /root/nginx/conf.d/:/etc/nginx/conf.d

(2).编译运行容器

#这里把docker-compose.yml放在该目录下
[root@MiWiFi-R3L-srv wwwroot]# ll
total 8740
-rw-r--r--. 1 root root    1428 Nov 22 05:13 docker-compose.yml
-rw-r--r--. 1 root root     143 Nov 22 04:04 Dockerfile
drwxrwxrwx. 5 root root      90 Nov 22 03:49 ginGorm
-rw-r--r--. 1 root root 8940056 Nov 22 04:00 ginGorm.tar.gz

#docker compose up 启动容器
[root@MiWiFi-R3L-srv wwwroot]# docker compose up
[+] Building 7.4s (10/10) FINISHED                                                                                     docker:default
 => [goweb01 internal] load .dockerignore                                                                                        0.5s
 => => transferring context: 2B                                                                                                  0.1s
 => [goweb01 internal] load build definition from Dockerfile                                                                     0.6s
 => => transferring dockerfile: 242B                                                                                             0.2s
 => [goweb01 internal] load

....

#查看通过docker compose 是否启动了mysql,goweb,nginx容器
[root@MiWiFi-R3L-srv wwwroot]# docker ps
CONTAINER ID   IMAGE             COMMAND                  CREATED         STATUS                          PORTS                                                  NAMES
2df006c60407   nginx             "/docker-entrypoint.…"   3 minutes ago   Restarting (1) 24 seconds ago                                                          nginx
1e374c641de3   wwwroot-goweb01   "./goweb"                3 minutes ago   Up 3 minutes                    0.0.0.0:8080->8080/tcp, :::8080->8080/tcp              goweb01
868ba8ad9178   mysql             "docker-entrypoint.s…"   3 minutes ago   Up 3 minutes                    0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp   myMysql

docker compose up

(3).后台运行

docker compose up -d

(4).一些问题

在 docker 运维的过程中经常会遇到一个问题，启动一个 docker - compose.yml 文件时，虽然使用 depends_on 属性用依赖关系定义了两个容器的启动顺序，但这个顺序仅仅是 docker 创建启动的顺序，而并不是在上一个容器完全启动成功的情况下启动下一个容器。depends_on 在启动 web 这个容器前，并不会等待db 和 redis 这个两个容器进入 ready状态，而只是等到它们被启动状态了,这里可以再次 重新启动相关容器,就可以解决(docker compose restart 容器名) ,也可以通过借助 wait-for-it.sh 配置 nginx+mysql+goWeb 项目配置容器启动顺序

wait-for-it.sh是GitHub中开源一个脚本，很轻量也很实用

注意： wait-for-it.sh 需要放在 ginGorm 文件中

这时需在docker-compose.yml中的goweb01下加入一下代码即可

command: ["./wait-for-it.sh","myMysql:3306","--","./goweb"]

3.docker compose 常用命令

(1).docker compose build命令

（重新）构建 docker - compose.yml 文件中的服务，生成镜像。如果一个服务是使用 build 元素构建的，那么一旦你更改了这个服务的 Dockerfile ，就需要运行 docker compose build 重新构建它，以保证之后 up 时运行的服务容器是最新的

docker compose build

选项：

        –force-rm：总是删除构建过程中的临时容器

        –no-cache：镜像构建过程中不使用 cache

        –pull：始终先尝试通过 pull 来获取最新版本的镜像

(2).docker compose up命令

这是最重要且最常用的一个命令，大部分时候都可以直接通过该命令来启动一个项目,它将自动完成构建镜像、（重新）创建服务、按依赖顺序启动任何关联的服务等一系列操作

docker compose up

默认情况下， docker compose up 启动的容器都在前台，控制台将实时打印所有容器的输出信息（以不同的颜色标识不同的服务），可以很方便进行调试。当按下 Ctrl+C 时，所有容器都会被停止。

如果使用 docker compose up -d ，则所有服务将在后台启动.一般生产环境下推荐使用该选项

docker compose up -d

需要注意的是，如果某个服务容器是通过build元素进行构建的，并且该服务对应的镜像已经存在，那么即使Dockerfile文件内容已经变更，docker compose up也不会重新构建该服务，此时你需要先执行 docker compose build构建镜像，再执行docker compose up

docker compose build && docker compose up

–scale：设置某个服务要启动的容器数量

提示:

需要在docker-compose.yml 中去掉container_name，去掉goweb01绑定的端口

docker compose up --scale='goweb01=3'
docker compose up --scale='goweb01=3' -d

选项：

-d：在后台运行服务容器

-no-deps：不启动服务所依赖的其他服务（由 depends_on 元素指定）

-no-color：不使用颜色来区分不同服务的控制台输出

-force-recreate：总是重新创建容器，不能与 --no-recreate 同时使用

-no-recreate：如果容器已经存在了，则不重新创建，不能与 --force-recreate 同时使用

-no-build：不进行服务镜像的构建，即使该服务镜像不存在

-t, --timeout TIMEOUT：停止容器时的超时时间（默认为 10 秒）

-scale：设置某个服务要启动的容器数量，用于快速扩容 / 缩容，例如 --scale='web=3' 将为 web 服务启动3 个容器副本，并且会覆盖 docker-compose.yml 中原有的 scales 设置

(3).docker compose stop命令

停止项目中的所有服务容器,稍后可以通过 docker compose start 再次启动

docker compose stop

(4).docker compose start命令

启动项目中的所有服务容器

docker compose start

(5).docker compose restart命令

重启项目中的所有服务容器,只是重启不会重新构建项目

docker compose restart

(6).docker compose convert

可以借助这个命令来验证 docker-compose.yml 文件格式是否正确,若错误则会显示错误原因

[root@localhost ~]# docker compose convert
yaml: line 9: did not find expected key

(7).docker compose exec

进入/退出容器类似，只不过它针对的是服务，可在指定的服务容器中执行命令

docker compose exec goweb01 /bin/bash

(8).docker compose images

列出所有已创建的服务容器的镜像信息

docker compose images

(9).docker compose ls

列出 Docker 上正在运行的所有项目，该信息与当前所在的项目无关

选项：

–all , -a：同时显示已停止的项目

[root@MiWiFi-R3L-srv wwwroot]# docker compose ls
NAME                STATUS                      CONFIG FILES
wwwroot             restarting(1), running(2)   /root/wwwroot/docker-compose.yml
[root@MiWiFi-R3L-srv wwwroot]# docker compose ls -a
NAME                STATUS                      CONFIG FILES
wwwroot             restarting(1), running(2)   /root/wwwroot/docker-compose.yml
[root@MiWiFi-R3L-srv wwwroot]#

(10).docker compose ps

查看docker compose运行的容器信息,类似于docker ps

docker compose ps

[root@MiWiFi-R3L-srv wwwroot]# docker compose ps
NAME      IMAGE             COMMAND                                          SERVICE   CREATED          STATUS                          PORTS
goweb01   wwwroot-goweb01   "./goweb"                                        goweb01   25 minutes ago   Up 21 minutes                   0.0.0.0:8080->8080/tcp, :::8080->8080/tcp
myMysql   mysql             "docker-entrypoint.sh mysqld"                    myMysql   25 minutes ago   Up 22 minutes                   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp
nginx     nginx             "/docker-entrypoint.sh nginx -g 'daemon off;'"   nginx     25 minutes ago   Restarting (1) 50 seconds ago

-a 查看 docker compose 运行的所有容器信息

docker compose ps -a

(11).docker compose logs

查看当前项目下所有服务容器的日志输出。默认情况下， docker compose logs 将对不同的服务输出使用不同的颜色来区分,可以通过 -- no - color 来关闭颜色,该命令在调试问题的时候十分有用。

docker compose logs

(12).docker compose port

打印某个服务容器的内部端口所映射的公共端口（宿主机端口）

选项:

–protocol=proto：指定端口协议， tcp （默认值）或者 udp

–index=index:如果同一服务存在多个容器副本,可用此选项指定容器的序号(默认为 1)

$ docker compose port mysql 3306
0.0.0.0:3307
$ docker compose port redis 6379
0.0.0.0:6380

(13).docker compose rm

删除所有已停止的服务容器,正式项目推荐先执行 docker compose stop 命令来停止容器,删除所有docker compose 容器

docker compose rm -f

(14).docker compose version

打印 Docker Compose 版本信息，该信息与当前所在的项目无关

docker compose version

(15).docker compose run

格式：
docker compose run [options] [-v VOLUME...] [-p PORT...] [-e KEY=VAL...] [-l
KEY=VALUE...] SERVICE [COMMAND] [ARGS...]
此命令的行为和创建并启动容器相似，它总是为某个服务创建并启动一个全新的容器,例如，以下命令为web 服务创建并启动一个容器，然后执行 /bin/bash 命令：

docker compose run goweb01 /bin/bash

此命令一定会创建一个新的容器，其配置由docker-compose.yml中的web服务所定义，包括数据卷、网络、依赖关系、环境变量等详细信息

此命令和 docker compose up 有两个重要区别：

此命令可以重写服务的启动命令（docker-compose.yml 中定义的 command 元素）

例如，如果 web 服务的启动命令是 /bin/bash （由 command 元素指定），那么

docker compose run goweb01 /bin/sh 将会把启动命令重写为/bin/sh

注意：

此命令不会自动创建docker-compose.yml中配置的任何端口映射，以避免端口冲突

如果确实想为服务创建端口并将其映射到宿主机，请指定端口：

docker compose run -d --name ginweb02 -p 8082:8080 goweb01

默认情况下，如果存在依赖关系（由depends_on元素指定）,则所有被依赖的服务将会被自动启动，除非这些服务已经在运行中,如果不希望 run 命令启动依赖的其他容器，请使用 --no-deps 选项

docker compose run --no-deps -d --name ginweb03 -p 8083:8080 goweb01

如果只想创建一次的容器，在容器停止后自动删除它，可以使用 --rm选项：

docker compose run --rm updateDb

选项：

        -d： 在后台运行容器

-name NAME： 为容器指定一个名字，默认为项目名 - 服务名 -uuid

-entrypoint CMD： 覆盖默认的容器启动命令

        -e KEY=VAL： 设置环境变量，可以多次指定此选项来设置多个环境变量

        -u, --user=“”： 指定运行容器的用户名或者 uid

-no-deps： 不启动所其他的其他服务容器

-rm： 容器运行完成时自动删除容器

        -p, --publish=[]： 手动映射容器端口到宿主机，和 3.1 创建并启动容器一样

-service-ports： 使 docker-compose.yml 中配置的端口映射生效，默认忽略

4.docker-compose 动态扩展容器

实现动态扩容,就是在启动容器的额时候多增加几个相关的容器,以便实现负载均衡等操作

(1).docker compose up --scale 实现容器扩容

需要删除docker-compose.yml中对应容器的掉container_name，去掉绑定的端口,如:

#指定docker-compose 版本
version: "3"

#services下就是容器的编写
services:
    #容器,
    myMysql:
        #来自哪个镜像
        image: mysql
        #容器名,如果不指定,则使用myMysql这个容器默认名称
        container_name: myMysql
        #环境变量:配置用户名,密码等
        environment:
            MYSQL_ROOT_PASSWORD: 123456
        #restart:  表示容器挂掉后是否重启, always 一直重启
        restart: always
        #映射的端口
        ports:
            - 3306:3306
        #数据卷的挂载
        volumes:
            - /root/mysql/conf.d:/etc/mysql/conf.d
            - /root/mysql/data:/var/lib/mysql
    #配置goweb01项目容器
    goweb01:
        #build编译成镜像,可以使用上面的/root/wwwroot/Dockerfile里面的
        build:
            context: ./
            dockerfile: Dockerfile
        #当然,也可以使用已经编译号的gowebimg镜像
        #image: gowebimg

        #container_name: goweb01
        restart: always
        #ports:
        #    - 8080:8080
        #depends_on表示创建好myMysql这个容器后,再来创建goweb01这个容器
        depends_on:
            - myMysql
    #配置nginx容器
    nginx:
        image: nginx
        container_name: nginx
        restart: always
        ports:
            - 80:80
        depends_on:
            - goweb01
        volumes:
            - /root/nginx/conf.d/:/etc/nginx/conf.d

然后执行:

docker compose up --scale='goweb01=3' -d

[root@MiWiFi-R3L-srv wwwroot]# docker compose up --scale='goweb01=3' -d
[+] Running 5/5
 ✔ Container myMysql            Started                                                                                          0.9s 
 ✔ Container wwwroot-goweb01-3  Started                                                                                          2.0s 
 ✔ Container wwwroot-goweb01-1  Started                                                                                          2.0s 
 ✔ Container wwwroot-goweb01-2  Started                                                                                          1.9s 
 ✔ Container nginx              Started                                                                                          0.8s 
[root@MiWiFi-R3L-srv wwwroot]# 
[root@MiWiFi-R3L-srv wwwroot]# docker compose ps
NAME                IMAGE             COMMAND                                          SERVICE   CREATED         STATUS                         PORTS
myMysql             mysql             "docker-entrypoint.sh mysqld"                    myMysql   3 minutes ago   Up 2 minutes                   0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060/tcp
nginx               nginx             "/docker-entrypoint.sh nginx -g 'daemon off;'"   nginx     3 minutes ago   Restarting (1) 4 seconds ago   
wwwroot-goweb01-1   wwwroot-goweb01   "./goweb"                                        goweb01   3 minutes ago   Up About a minute              8080/tcp
wwwroot-goweb01-2   wwwroot-goweb01   "./goweb"                                        goweb01   3 minutes ago   Up About a minute              8080/tcp
wwwroot-goweb01-3   wwwroot-goweb01   "./goweb"                                        goweb01   3 minutes ago   Up About a minute              8080/tcp

(2).通过docker-compose.yml配置容器副本以及占用的cpu

#指定docker-compose 版本
version: "3"

#services下就是容器的编写
services:
    #容器,
    myMysql:
        #来自哪个镜像
        image: mysql
        #容器名,如果不指定,则使用myMysql这个容器默认名称
        container_name: myMysql
        #环境变量:配置用户名,密码等
        environment:
            MYSQL_ROOT_PASSWORD: 123456
        #restart:  表示容器挂掉后是否重启, always 一直重启
        restart: always
        #映射的端口
        ports:
            - 3306:3306
        #数据卷的挂载
        volumes:
            - /root/mysql/conf.d:/etc/mysql/conf.d
            - /root/mysql/data:/var/lib/mysql
    #配置goweb01项目容器
    goweb01:
        #build编译成镜像,可以使用上面的/root/wwwroot/Dockerfile里面的
        build:
            context: ./
            dockerfile: Dockerfile
        #当然,也可以使用已经编译号的gowebimg镜像
        #image: gowebimg

        #container_name: goweb01
        restart: always
        #ports:
        #    - 8080:8080
        
        deploy:
            replicas: 3 #副本数量
            resources: #资源
                limits: #配置cpu
                    cpus: "0.5" # 设置该容器最多只能使用 50% 的 CPU
                    memory: 500M # 设置该容器最多只能使用 500M内存
            restart_policy: #定义容器重启策略, 用于代替 restart 参数
                condition: on-failure #只有当容器内部应用程序出现问题才会重启

        #depends_on表示创建好myMysql这个容器后,再来创建goweb01这个容器
        depends_on:
            - myMysql
    #配置nginx容器
    nginx:
        image: nginx
        container_name: nginx
        restart: always
        ports:
            - 80:80
        depends_on:
            - goweb01
        volumes:
            - /root/nginx/conf.d/:/etc/nginx/conf.d