Docker的使用

Docker的使用
一、docker的简介
1. Docker 是基于Go语言实现的开源容器项目。利用操作系统本身已有的机制和特性，可以实现远超传统虚拟机的轻量级虚拟化。它是内核级的虚拟化。期望达到使项目运行环境“一次封装，到处运行的目的”。
  - 利用docker创建的运行环境叫做docker容器，容器是通过docker镜像创建的，docker镜像文件可以放在私有仓库中也可以放在共有仓库中。
1、docker与虚拟机VMware的区别

Docker和虚拟机（VM）是两种不同的技术，它们各自有着不同的优势和应用场景。
- Docker是一种轻量级的容器技术，可以将应用及其依赖项打包到一个可移植的容器中，使得应用可以在任何环境中都能够运行。Docker容器与主机共享内核和系统资源，因此启动速度快、占用资源少、易于部署和管理。Docker还可以快速创建多个相互隔离的应用容器，每个容器都可以运行不同的应用程序或服务。它可以帮助开发人员和运维人员更加高效地部署、管理和运行应用程序。
- 虚拟机则是一种完整的虚拟计算机，可以模拟出一台完整的计算机系统，包括硬件、操作系统和应用程序等。每个虚拟机都有自己的操作系统内核和系统资源，因此可以运行不同的操作系统或应用程序。虚拟机通常比Docker更为灵活，但启动速度较慢，占用资源多，部署和管理也较为复杂。
- 综上所述
  - Docker适合运行轻量级的、相对简单的应用程序或服务，并且需要频繁地进行部署和更新；
  - 虚拟机则适合运行更为复杂的应用程序或服务，并且需要更高的隔离性和安全性。
注意：Docker并不是为了替代虚拟机，虚拟机是系统级别，而Docker是应用级，各自的场景不同而已

 2、docker的优点
1. 启动速度：
  - 每个虚拟都机是一个完整的操作系统包括操作系统和内核，所以它是一个重量级的系统；而容器是轻量级的，因为容器只打包了操作系统的基础文件和库文件、还有应用程序及所有的依赖，他的运行速度就如同在系统中创建一个进程一样快，所以启动速度较快。
2. 运行性能：
  - 由于虚拟机增加了虚拟化层用于虚拟化硬件，势必会增加一定的开销，所以运行性能有所损失；而容器是直接运行在物理操作系统上的，他本身与系统上其他进程并没有太大区别，所以运行性能是接近原生的操作系统
3. 磁盘占用：
  - 虚拟机是一个完整的操作系统，是 GB 级别的，而容器只包含了一些系统启动的必要组件和程序依赖，是 MB 级别的。占用的磁盘非常小，可以节约磁盘空间
4. 容器数量：
  - 一台物理机虚拟的操作系统相对有限，而Docker是在一台虚拟机中运行多个进程而已，运行一个进程的开销较小，同样的服务器资源可以运行更多的容器。
3、docker架构
- Docker daemon（Docker守护进程）
  - Docker daemon是一个运行在宿主机（DOCKER_HOST）的后台进程。我们可通过Docker客户端与之通信。
- Client（Docker客户端）
  - Docker客户端是Docker的用户界面，它可以接受用户命令和配置标识，并与Docker daemon通信。图中，docker build等都是Docker的相关命令。
- Images（Docker镜像）
  - Docker镜像是一个只读模板，它包含创建Docker容器的说明。它和系统安装光盘有点像——我们使用系统安装光盘安装系统，同理，我们使用Docker镜像运行Docker镜像中的程序。
- Container（容器）
  - 容器是镜像的可运行实例。镜像和容器的关系有点类似于面向对象中，类和对象的关系。我们可通过Docker API或者CLI命令来启停、移动、删除容器。
- Registry（仓库）
  - Docker Registry是一个集中存储与分发镜像的服务。我们构建完Docker镜像后，就可在当前宿主机上运行。但如果想要在其他机器上运行这个镜像，我们就需要手动拷贝。此时，我们可借助Docker Registry来避免镜像的手动拷贝。
一个Docker Registry可包含多个Docker仓库；每个仓库可包含多个镜像标签；每个标签对应一个Docker镜像。这跟Maven的仓库有点类似，如果把Docker Registry比作Maven仓库的话，那么Docker仓库就可理解为某jar包的路径，而镜像标签则可理解为jar包的版本号。

二、docker的安装与启动

 1、docker的安装
1. 下载docker-ce repo
  - docker-ce是docker的社区版
- 为本地yum提供远程repo信息。
```
curl https://download.docker.com/linux/centos/docker-ce.repo -o /etc/yum.repos.d/docker-ce.repo
```
1. 安装依赖
  - 需要安装yum工具才能使用yum
```
yum install -y yum-utils
```
```
yum install -y https://mirrors.aliyun.com/docker-ce/linux/centos/7.9/x86_64/stable/Packages/containerd.io-1.4.8-3.1.el7.x86_64.rpm
```
1. 安装docker
```
yum install -y docker-ce
```
2、docker的启动与关闭
- 启动命令
```
systemctl start docker
```
- 关闭命令
```
systemctl stop docker
```
- 查看docker服务的状态
```
systemctl status docker
```
- 查看docker的状态命令
```
docker info
```
- 测试docker安装是否成功
  - 使用docker pull hello-world:latest 命令下载镜像到docker
  - 使用docker run hello-world 创建容器并且执行该程序
- 执行docker ps命令，如果不报错，说明安装启动成功
```
docker ps
```
配置docker开机自启动
```
systemctl enable --now docker.service

systemctl enable --now docker.socket 
```
systemctl enable --now docker.service和systemctl enable docker都是用来启用docker服务的命令，但是它们之间有一些不同。
- systemctl enable docker只是将docker服务添加到系统启动项中，这样系统在启动时会自动启动docker服务，但是不会立即启动docker服务。
- 而systemctl enable --now docker.service则不仅将docker服务添加到系统启动项中，而且还会立即启动docker服务。
  - 因此，如果你只是想将docker服务添加到系统启动项中，可以使用systemctl enable docker；如果你想将docker服务添加到系统启动项并立即启动docker服务，则应该使用systemctl enable --now docker.service。
3、docker配置镜像加速
1. 默认情况下Docker从Docker Hub上下载镜像资源，但速度很慢，可以通过配置国内的镜像加速器来解决。
Docker Hub
1. 我们可以从Docker Hub直接下载镜像安装到一个容器里面。我们也可以上传镜像到DockerHub，但是需要登录。我们可以在docker hub上面查看是否我们需要的软件以及版本。网站为：https://hub.docker.com
以阿里云镜像为例

阿里云官网：https://www.aliyun.com/

选择对应的OS并配置
```
# sudo表示以root用户的权限进行操作（当前用户如果是root，要不要sudo都行
# 创建目录
mkdir -p /etc/docker

# 复制内容，注意把其中的镜像加速地址改成你自己的
tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://xxxx.mirror.aliyuncs.com"]
}
EOF

# 重新加载配置
systemctl daemon-reload

# 重启Docker
systemctl restart docker
```
- 通过docker info命令查看镜像配置是否成功
三、Docker镜像操作-Images
1. 什么是docker镜像：Docker镜像是由文件系统叠加而成（是一种文件的存储形式）。最底端是一个文件引导系统，即bootfs，这很像典型的Linux/Unix的引导文件系统。Docker用户几乎永远不会和引导系统有什么交互。实际上，当一个容器启动后，它将会被移动到内存中，而引导文件系统则会被卸载，以留出更多的内存供磁盘镜像使用。Docker容器启动是需要一些文件的，而这些文件就可以称为Docker镜像。
1、列出docker下的所有镜像
```
docker images 
# 或者 
docker image ls
```
- 结果参数说明：
  - REPOSITORY：镜像所在的仓库名称
  - TAG：镜像标签(版本)
  - IMAGE ID：镜像ID
  - CREATED：镜像的创建日期（不是获取该镜像的日期）
  - SIZE：镜像大小
2、查找镜像
1. 可使用命令搜索需要的镜像
```
docker search 镜像名称
```
- 查询结果参数说明：
  - NAME：仓库名称
  - DESCRIPTION：镜像描述
  - STARS：用户评价，反应一个镜像的受欢迎程度
  - OFFICIAL：是否官方
  - AUTOMATED：自动构建，表示该镜像由Docker Hub自动构建流程创建的
3、拉取镜像
1. 拉取镜像相当于从远程Registry中下载镜像到本地
```
# 命令：（不带版本号，默认下载最新的那个（latest））
docker pull 镜像名称 

# 命令(带版本号）
docker pull 镜像名 [标签]
```
4、删除镜像
```
# 删除本地镜像使用命令：
# IMAGE_ID,REPOSITORY,TAG均是images下的参数
# 根据IMAGE_ID进行删除镜像
docker rmi $IMAGE_ID

# 根据REPOSITORY进行删除镜像
docker rmi $REPOSITORY:$TAG
```
-f：表示强制删除

 四、docker容器操作
1. 可以把容器看成简易版的Linux环境（包括root用户权限，进程空间，用户空间和网络空间等）和运行在其中的应用程序。
2. 容器是隔离环境，外界不可访问。但是可以将宿主机端口映射容器内到端口，当访问宿主机指定端口时，就是在访问容器内的端口了。
  - 容器内端口往往是由容器内的进程决定，例如MySQL进程默认端口是3306，因此容器内端口一定是3306；而宿主机端口则可以任意指定，一般与容器内保持一致。
1、新建容器
1. 语法：
```
docker create [options] 镜像名字或者ID [COMMAND] [ARG...]
```
1. 举例：
```
# 例：创建一个mysql容器
docker create -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=root mysql 

# 例：创建一个有映射路径的mysql容器
docker create -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=root \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
--restart=always mysql

# Docker容器开机自启
docker update --restart=always [容器名/容器id]
# --restart=always mysql表示开机自启mysql容器
```
- options 常见参数说明
```
--name：给容器起一个新名字。为容器指定一个名称
--restart : 设置是否重启容器自动启动，默认no always：自动重启
-i：以交互模式运行容器，通常与-t连用
-t：为容器重新分配一个伪终端，通常与-i连用
-P：随机端口映射
-p：指定端口映射，hostPost：containerPort
-e：配置信息
-d：后台执行（创建并启动时候）
-v：主机和容器的目录映射关系，":"前为主机目录，之后为容器目录 
```
2、启动容器
1. 语法：
```
docker start 容器ID/容器名

# 例子：
docker start mysql
```
3、停止容器
1. 语法：
```
docker stop 容器ID/容器名

# 例子：
docker stop mysql
```
4、新建并启动容器
1. 语法：
```
docker run [options] 镜像名字或者ID [COMMAND] [ARG...]
```
1. 举例：
```
#  例：创建一个mysql容器并且在后台运行（-d）
docker run -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=root -d mysql 

# 例：创建一个有映射路径的mysql容器并且在后台运行（-d）
docker run -p 3306:3306 --name mysql_new -e MYSQL_ROOT_PASSWORD=root \
-v /usr/local/docker/mysql/data:/var/lib/mysql \
--restart=always -d mysql
```
5、列出启动的容器
1. 列出正在运行的容器：
```
docker container ls
```
1. 查看docker容器进程信息：
```
docker ps [options]
```
- options 参数说明
```
-l：显示最近创建的容器
-n 数字：显示最近n个创建的容器
-a：列出所有的容器
-q：列出容器id
docker container ls -a 
```
6、强制停止容器
1. 不推荐使用，容易造成容器服务不正常关闭，影响后续使用。
```
# 语法：
docker kill 容器ID或名称

# 示例：
docker kill mysql
```
7、暂停容器
```
# 语法：
docker pause 容器ID或名称

# 示例：
docker pause mysql
```
8、恢复容器
1. 把暂停的容器恢复。
```
# 语法：
docker unpause 容器ID或名称

# 示例：
docker unpause mysql
```
9、删除容器
1. 要删除的容器，必须是关闭状态的。（没有关闭的可以使用-f进行强制关闭）
```
# 语法：
docker rm 容器ID或名称

# 示例：
docker rm mysql
```
10、查看容器日志
```
# 语法：
docker logs -f -t --tail 行数 容器ID

# 示例：
docker logs -f -t --tail 5 mysql
```
参数说明
```
-f 参数代表长期监控日志数据
-t 额外增加时间戳
--tail 行数 显示末尾多少行日志
```
11、查看容器中运行的进程
```
# 语法：
docker top 容器ID或名称

# 示例：
docker top mysql
```
12、查看容器内部详情
```
# 语法：
docker inspect 容器ID或名称

# 示例：
docker inspect mysql
```
13、复制容器数据到宿主机
```
# 语法：
docker cp 容器ID或名称:容器内路径 宿主机路径

# 示例：复制MySQL配置到宿主机：
 docker cp mysql:/etc/mysql ~/tmp/conf
```
14、与运行中的容器交互（重点）
```
# 语法：
docker exec [options] 容器ID [command]

# 示例：
docker exec -it mysql bash
```
可以把容器理解成简易版的Linux环境（包括root用户权限，进程空间，用户空间和网络空间等）和运行在其中的应用程序。
- options参数说明
```
-i：以交互模式运行容器，通常与-t连用
-t：为容器重新分配一个伪终端，通常与-i连用
```
数据卷
1. 容器是隔离环境，容器内程序的文件、配置、运行时产生的容器都在容器内部，我们要读写容器内的文件非常不方便。大家思考几个问题：
  - 如果要升级MySQL版本，需要销毁旧容器，那么数据岂不是跟着被销毁了？
  - MySQL、Nginx容器运行后，如果我要修改其中的某些配置该怎么办？
  - 我想要让Nginx代理我的静态资源怎么办？
- 解答：容器提供程序的运行环境，但是程序运行产生的数据、程序运行依赖的配置都应该与容器解耦。
数据卷简介
1. 数据卷（volume）是一个虚拟目录，是容器内目录与宿主机目录（当前虚拟机操作的linux系统的目录）之间映射的桥梁。
- /var/lib/docker/volumes这个目录就是默认的存放所有容器数据卷的目录
以nginx为例
1. Nginx中有两个关键的目录：
  - html：放置一些静态资源
  - conf：放置配置文件
2. 如果我们要让Nginx代理我们的静态资源，最好是把静态资源放到html目录；如果我们要修改Nginx的配置，最好是找到conf下的nginx.conf文件。
  - 但遗憾的是，容器运行的Nginx所有的文件都在容器内部。所以我们必须利用数据卷将两个目录与宿主机目录关联，这样我们就可以通过操作宿主机目录去关联操作到容器的目录了（两个目录关联后，宿主机目录变化，容器目录也会跟着变化）。
- 在上图中：
  - 我们在宿主机上创建了两个数据卷：conf（/var/lib/docker/volumes/conf)、html（/var/lib/docker/volumes/html)
  - Nginx容器内部的conf目录和html目录分别与两个数据卷关联。
  - 而数据卷conf和html分别指向了宿主机的/var/lib/docker/volumes/conf/_data目录和/var/lib/docker/volumes/html/_data目录
  - 这样一来，容器内的conf和html目录就与宿主机的conf和html目录关联起来，我们称为挂载。此时，我们操作宿主机的/var/lib/docker/volumes/html/_data就是在操作容器内的/usr/share/nginx/html/_data目录。只要我们将静态资源放入宿主机对应目录，就可以被Nginx容器代理了。
为什么不让容器目录直接指向宿主机目录呢？
- 因为直接指向宿主机目录就与宿主机强耦合了，如果切换了环境，宿主机目录就可能发生改变了。由于容器一旦创建，目录挂载就无法修改，这样容器就无法正常工作了。
- 但是容器指向数据卷，一个逻辑名称，而数据卷再指向宿主机目录，就不存在强耦合。如果宿主机目录发生改变，只要改变数据卷与宿主机目录之间的映射关系即可。
不过，我们通过由于数据卷目录比较深，不好寻找，通常我们也允许让容器直接与宿主机目录挂载而不使用数据卷

 数据卷相关命令
```
# 创建数据卷
docker volume create 数据卷名称

# 查看所有数据卷
docker volume ls

# 删除指定数据卷
docker volume rm 数据卷名称

# 查看某个数据卷的详情
docker volume inspect 数据卷名称

# 清除数据卷
docker volume prune 数据卷名称
```
注意：容器与数据卷的挂载要在创建容器时配置，对于创建好的容器，是不能设置数据卷的。而且在创建容器的过程中，如果挂载了数据卷且数据卷不存在，数据卷会自动创建。
```
# 创建容器并指定数据卷，注意通过 -v 参数来指定数据卷
docker run -d --name nginx -p 80:80 -v html:/usr/share/nginx/html nginx

# 这里的html就是数据卷的名称，数据卷默认的存放位置是/var/lib/docker/volumes这个目录
```
```
# 创建容器没有指定数据卷
docker run -d \
  --name mysql \
  -p 3306:3306 \
  -e TZ=Asia/Shanghai \
  -e MYSQL_ROOT_PASSWORD=123 \
  mysql
```
在创建容器时，如果没有定义数据卷，会默认创建一个匿名数据卷。

挂载本地目录或文件
1. 数据卷的目录结构较深，如果我们去操作数据卷目录会不太方便。在很多情况下，我们会直接将容器目录与宿主机指定目录挂载。挂载语法与数据卷类似：
```
# 挂载本地目录
-v 本地目录:容器内目录
# 挂载本地文件
-v 本地文件:容器内文件
```
- 注意：本地目录或文件必须以 / 或 ./开头，如果直接以名字开头，会被识别为数据卷名而非本地目录名。
```
-v mysql:/var/lib/mysql 
# 会被识别为一个数据卷叫mysql，运行时会自动创建这个数据卷

-v ./mysql:/var/lib/mysql 
# 会被识别为当前目录下的mysql目录，运行时如果不存在会创建目录
```
docker挂载数据卷与挂载目录的区别
1. Docker的数据卷和挂载目录都是将主机文件系统中的目录挂载到容器中，使得容器可以访问主机中的文件或目录。它们的区别在于，数据卷是由Docker管理的，而挂载目录是直接将主机目录挂载到容器中。
  - 具体来说，数据卷是一种特殊的目录，它可以在容器和主机之间共享数据，并且可以在容器之间共享。当容器被删除时，数据卷不会自动删除。如果要删除一个数据卷，需要手动执行命令。数据卷通常用于存储应用程序和数据。
  - 而挂载目录则是将主机上的目录直接挂载到容器中，可以通过 -v 参数来指定挂载的目录。当容器被删除时，挂载的目录也会被删除。挂载目录通常用于调试和开发。
2. 在创建容器时，Docker会自动创建数据卷，但不会自动创建挂载目录。如果需要挂载目录，则需要手动指定挂载的目录。
五、docker的File管理（案例构建一个java工程镜像。）
1. Docker File是用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。
1、使用本地命令构建镜像

 1.1、上传项目jar
- 当前以部署一个普通的springboot项目为例。
  - 实际开发一般情况都是docker配合分布式+微服务项目
    第1步：上传一个springboot项目jar包到linux
    第2步：将jar包上传linux服务器/usr/local/docker-app/springboot_demo/目录，在jar包所在目录创建名为Dockerfile的文件
- 创建目录命令
```
mkdir -p /usr/local/docker-app/springboot_demo/
```
- 将jar包上传linux服务器/usr/local/docker-app/springboot_demo/目录
1.2、下载JDK镜像
1. 一般使用openjdk镜像。
```
# 查看有哪些openjdk的镜像可以下载（拉取）
docker search openjdk #（不指定版本就是下载最新的）

# 拉取镜像
docker pull openjdk
```
1.3、创建构建文件
1. 要构建到镜像中的jar文件需要和buildFile处于同一个目录。
```
# 使用vi编辑器进入Dockerfile
vi Dockerfile

# Dockerfile里面要写的内容
FROM openjdk:8
ADD springboot_demo01-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]
EXPOSE 8761
```
1.4、语法解释
```
#指定基础镜像，这个需要根据自己配置的仓库上的版本写
FROM openjdk:8

#指定源包，赋值到容器，前者是你的jar包,后面是别名
ADD spring_boot_demo01-1.0-SNAPSHOT.jar app.jar

#指定容器启动时执行的命令
ENTRYPOINT ["java","-jar","/app.jar"]

#对外端口
EXPOSE 8080
```
1.5、构建镜像
```
# 语法：
docker build -f 构建文件 -t 镜像名称:TAG 相对目录（如果是镜像构建当前目录就是点）

# 示例：
docker build -f /usr/local/docker-app/springboot_demo/buildFile -t springbootdemo:1.0 .
```
1.6、启动
```
docker run --name springbootdemo -p 8080:8080 -d springbootdemo:1.0
```
1.7、浏览器访问：

2、使用IDEA构建镜像

 1、修改Docker服务配置
```
vim /usr/lib/systemd/system/docker.service
```
1. 编辑/usr/lib/systemd/system/docker.service内容，在ExecStart变量末尾，增加下述配置：
```
-H unix:///var/run/docker.sock -H 0.0.0.0:2375
```
参数说明
```
-H unix:///var/run/docker.sock : 开启一个对外主机服务，使用docker.sock文件管理。
-H 0.0.0.0:2375 : 允许什么客户端IP访问当前服务，当前服务对外暴露的端口号是什么。端口可自定义。
```
2、重启docker服务
```
# 重新加载配置
systemctl daemon-reload 

# 重新启动docker
systemctl restart docker
```
3、在IDEA项目POM依赖
1. 新增plugin插件配置
```
<plugin>
    <groupId>com.spotifygroupId>
    <artifactId>docker-maven-pluginartifactId>
    <version>1.2.2version>
    <configuration>
        <imageName>springboot_demo:1.0imageName>  
        <baseImage>openjdk:latestbaseImage> 
        <dockerHost>http://192.168.126.10:2375dockerHost>  
        <entryPoint>["java","-jar","/${project.build.finalName}.jar"]entryPoint> 
        <exposes>
            <expose>8080expose>
        exposes>
        <resources>
            <resource>
                <targetPath>/targetPath> 
                <directory>${project.build.directory}directory> 
                <include>${project.build.finalName}.jarinclude> 
            resource>
        resources>
    configuration>
plugin>
```
4、配置构建构建docker镜像命令

 5、查看镜像

 6、创建并启动容器

 7、浏览器器访问

 六、容器编排DockerCompose
- 问题：使用微服务架构的应用系统一般包含若干个微服务，每个微服务一般都会部署多个实例。如果每个微服务都要手动启停，那么维护部署效率非常低。
  - 解决方案：使用DockerCompose
1、Compose 简介
1. Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。
2. Compose 使用的三个步骤：
  - 使用 Dockerfile 定义应用程序的环境。
  - 使用 docker-compose.yml 配置构成应用程序的服务。这个配置文件可以按照规则配置任意N个docker容器信息
  - 最后，执行 docker-compose up 命令来启动并运行整个应用程序。
2、Docker-Compose安装

 2.1、下载docker-compose

下载地址

 2.2、把下载好的docker-compose-linux-x86_64上传到linux的/usr/local/bin目录下

 2.3、修改文件名称为docker-compose（原来的名称不好用）
```
mv docker-compose-linux-x86_64 docker-compose
```
2.4、给docker-compose添加执行权限
```
sudo chmod +x /usr/local/bin/docker-compose
```
2.5、创建软连接
1. 软连接类似windows的快捷方式
```
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
```
2.6、测试安装是否成功

输入docker-compose version 命令
```
docker-compose version
```
3、使用Docker-Compose启动容器

示例：使用docker-compose方式来创建一个mysql的容器
- 创建一个目录，我们后面所有docker-compose文件都存放在此目录、
  - 目录的意义：docker操作下的compose（编排）操作
```
mkdir -p /home/docker/compose
```
- 进入目录
```
cd /home/docker/compose
```
- 创建一个mysql目录(因为编排的是mysql）
  - 编排其他的服务时，可以在/home/docker/compose目录下继续创建新的目录，比如要操作redis就创建redis目录
```
# 在这个目录下 /home/docker/compose 创建mysql
mkdir mysql
```
- 创建docker-compose.yml文件
```
touch docker-compose.yml
```
- 编辑docker-compose.yml文件
```
version: '1.0' #版本，可以任意给
services: #配置服务 s 代表负数，下面可以配置多个容器信息
    mysql1: #自定义服务名称，随意（见名知意）
          image: mysql:latest #镜像以及版本，当前mysql
          container_name: mysql1 #容器名称
          restart: always #是否跟随系统启动自动启动
          ports: #端口映射
            - 3311:3306
          volumes: #容器卷映射。是否映射要看
            - /root/docker-compose/mysql1/data:/var/lib/mysql-compose
            - /root/docker-compose/mysql1/config:/etc/mysql-compose
          environment: #mysql的环境配置
            MYSQL_ROOT_PASSWORD: 123456
```
参数的说明
```
-version  文件格式的版本
services 配置服务 s 代表负数，下面可以配置多个容器信息
container_name 服务定义， mysql1 是容器的名称
image nginx容器所使用的镜像:版本
ports 定义端口映射，宿主机对外暴露的端口：容器端口
volumes 目录映射
```
docker-compose.yml配置很多，具体配置根据实际情况选择即可
docker-compose.yml文件官方文档
- 启动容器
  - 在 docker-compose.yml 文件所在目录执行
    也可在任意位置执行：docker-compose -f /root/docker-compose/docker-compose.yml up -d
```
docker compose up -d
```
options参数说明
```
1. up 表示启动
2. -d 表示后台运行
3. -f 指定 docker-compose 文件位置 docker-compose -f /root/docker-compose/docker-compose.yml up -d
```
4、Dockerdocker-compose 常用命令

在 docker-compose.yml 文件所在目录执行
- 启动容器
```
docker-compose up -d
```
- 停止容器
```
docker-compose down
```
- 重启容器
```
docker-compose restart
```
- 重载 docker-compose.yml
```
# 重新加载创建容器
docker-compose up --force-recreate -d
```
5、使用Docker-Compose启动多容器
1. 此处案例同时启动两个mysql，只需要在docker-compose.yml中配置多个容器服务信息即可,其他操作和上面的一样。
```
version: '1.0' #版本，可以任意给
services: #配置服务 s 代表负数，下面可以配置多个容器信息
    mysql22: #自定义服务名称，随意（见名知意）
          image: mysql:latest #镜像以及版本，当前mysql
          container_name: mysql22 #容器名称
          restart: always #是否跟随系统启动自动启动
          ports: #端口映射
            - 3322:3306
          volumes: #容器卷映射。是否映射要看
            - /root/docker-compose/mysql22/data:/var/lib/mysql-compose
            - /root/docker-compose/mysql22/config/my.cnf:/etc/mysql-compose/my.cnf
          environment: #mysql的环境配置
            MYSQL_ROOT_PASSWORD: 123456
    mysql23:
      image: mysql:latest
      container_name: mysql23
      restart: always #是否跟随系统启动自动启动
      ports:
        - 3323:3306
      volumes:
        - /root/docker-compose/mysql23/data:/var/lib/mysql-compose
        - /root/docker-compose/mysql23/config/my.cnf:/etc/mysql-compose/my.cnf
      environment:
        MYSQL_ROOT_PASSWORD: 123456
```
测试连接：
相关阅读:
详解 SpringMVC 的 HttpMessageConverter
升级HarmonyOS 4.2，开启健康生活篇章
 idea快捷键 | 代码整体左移或右移（PyCharm）
CentOS7 设置固定IP地址
 学弟：功能测试转测试开发容易吗？
Java BufferedOutputStream类的简介说明
 搭建本地人工智能框架LocalAI
基于Java实现的贪吃蛇大作战小游戏
 全网最全谷粒商城记录_08、环境-linux安装docker——2、虚拟机安装上docker
【第十四章网络编程要素（IP和端口，网络通信协议），实现TCP的网络编程】
原文地址：https://blog.csdn.net/weixin_64044840/article/details/139246072

一、docker的简介

1、docker与虚拟机VMware的区别

2、docker的优点

3、docker架构

二、docker的安装与启动

1、docker的安装

2、docker的启动与关闭

配置docker开机自启动

3、docker配置镜像加速

Docker Hub

以阿里云镜像为例

三、Docker镜像操作-Images

1、列出docker下的所有镜像

2、查找镜像

3、拉取镜像

4、删除镜像

四、docker容器操作

1、新建容器

2、启动容器

3、停止容器

4、新建并启动容器

5、列出启动的容器

6、强制停止容器

7、暂停容器

8、恢复容器

9、删除容器

10、查看容器日志

11、查看容器中运行的进程

12、查看容器内部详情

13、复制容器数据到宿主机

14、与运行中的容器交互（重点）

数据卷

数据卷简介

以nginx为例

为什么不让容器目录直接指向宿主机目录呢？

数据卷相关命令

挂载本地目录或文件

docker挂载数据卷与挂载目录的区别

五、docker的File管理（案例构建一个java工程镜像。）

1、使用本地命令构建镜像

1.1、上传项目jar

1.2、下载JDK镜像

1.3、创建构建文件

1.4、语法解释

1.5、构建镜像

1.6、启动

1.7、浏览器访问：

2、使用IDEA构建镜像

1、修改Docker服务配置

2、重启docker服务

3、在IDEA项目POM依赖

4、配置构建构建docker镜像命令

5、查看镜像

6、创建并启动容器

7、浏览器器访问

六、容器编排DockerCompose

1、Compose 简介

2、Docker-Compose安装

2.1、下载docker-compose

2.2、把下载好的docker-compose-linux-x86_64上传到linux的/usr/local/bin目录下

2.3、修改文件名称为docker-compose（原来的名称不好用）

2.4、给docker-compose添加执行权限

2.5、创建软连接

2.6、测试安装是否成功

3、使用Docker-Compose启动容器

4、Dockerdocker-compose 常用命令

5、使用Docker-Compose启动多容器