[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

然后执行docker compose up -d,同样可以创建多个容器,当某个容器挂掉后,就回去访问另一个容器,这样就到了负载均衡操作,好了,docker compose 讲解完毕,下一节讲解Docker Swarm

[上一节][Docker]八.Docker 容器跨主机通讯