DockerDocker 是一个开源的容器化平台，可以将应用及其依赖打包成镜像，运行在隔离的容器中，实现跨环境一致部署，

Docker基础

一、安装和卸载

安装Docker

1.卸载旧内容

sudo yum remove docker \
                docker-client \
                docker-client-latest \
                docker-common \
                docker-latest \
                docker-latest-logrotate \
                docker-logrotate \
                docker-engine

2.安装yum工具

sudo yum install -y yum-utils

3.设置镜像源

sudo yum-config-manager \
  --add-repo \
  https://download.docker.com/linux/centos/docker-ce.repo

4.安装Docker

sudo yum install docker-ce docker-ce-cli containerd.io

5.启动Docker

sudo systemctl start docker

6.查看Docker版本

docker --version

如果显示docker的版本信息即代表安装成功

卸载Docker

1.卸载依赖

sudo yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras

2.删除工作路径

sudo rm -rf /var/lib/docker

3.删除容器路径

sudo rm -rf /var/lib/containerd

二、Docker命令

官方文档命令地址：docs.docker.com/engine/refe…

1.系统命令

docker的系统信息

docker info

停止docker

systemctl stop docker

docker命令列表

docker --help

查看"xxx"命令的作用

docker xxx --help

2.镜像命令

查看镜像

docker images

列出所有的镜像

docker images -a

列出所有镜像的id

docker images -aq

搜索镜像

docker search 镜像名

搜索stars数大于3000的xxx镜像

docker search 镜像名 --filter=STARS=3000

下载镜像

docker pull 镜像名

不加版本时默认latest版本

等价于：docker pull docker.io/library/mysql:latest (:latest表示最新版本)

下载指定版本镜像

docker pull 镜像名:版本

等价于：docker pull docker.io/library/mysql:2.0 (:2.0表示2.0版本)

删除镜像

docker rmi -f 镜像id

删除多个镜像

docker rmi -f 镜像id1 镜像id2 镜像id3

删除所有镜像

docker rmi -f $(docker images -aq)

$(docker images -aq)：列出所有镜像id

3.容器命令

启动容器

docker run -d 镜像名:镜像版本

启动已存在的容器

docker start 容器名或容器id

重启容器

docker restart 容器名或容器id

启动并进入容器

docker run -it 镜像名:镜像版本 /bin/bash

docker run 参数说明
--name 容器名			// 设置容器名 用来区分容器
-d			// 后台方式运行
-it			// 使用交互方式运行，进入容器查看内容
-P			// 大写p 随机端口运行
-p 主机端口:容器端口			// 小写p，指定端口运行

查看容器

列出当前运行的容器

docker ps

docker container ls

列出所有容器

docker ps -a

列出所有容器的id

docker ps -q

停止容器

停止正在运行的容器

docker stop 容器名或容器id

强制停止正在运行的容器

docker kill 容器名或容器id

删除容器

删除容器（不能删除正在运行的容器）

docker rm 容器名或容器id

删除容器（包括正在运行的容器）

docker rm -f 容器名或容器id

删除所有容器（包括正在运行的容器）

docker rm -f $(docker ps -aq)

4.常用命令

详细信息

容器详细信息

docker inspect 容器名或容器id

容器在宿主机的目录

/var/lib/docker/containers/

日志

查看容器所有日志

docker logs -tf 容器名或容器id

查看容器最近的10条日志

docker logs -tf --tail 10 容器名或容器id

进程

查看容器的进程信息

docker top 容器名或容器id

进入容器

创建新终端进入

docker exec -it 容器名或容器id /bin/bash

docker exec -it 容器名或容器id /bin/sh

不创建新终端进入

docker attach 容器名或容器id

root权限进入

docker exec -u 0 -it 容器名或容器id sh

docker exec -it --user=root 容器名或容器id /bin/bash

文件拷贝

容器中拷贝到主机（将容器中的home目录下的"xxx.go"文件拷贝到主机"home/go"目录中）

docker cp 容器名或id:/home/xxx.go home/go

宿主机拷贝到容器（将主机当前目录下的"xxx.go"文件拷贝到主机"/data/themes"目录中）

docker cp xxx.go 容器名或id:/data/themes/

镜像复制

复制镜像"centos:1.0" ,并将复制后的新镜像命名为"vczs/mycentos:2.0"

docker tag centos:1.0 vczs/mycentos:2.0

Docker进阶

一、DockerVolume

概念

引出

1.我们的数据都在容器中，如果容器删除，数据就丢失。
2.需要一种技术可以将容器中的数据同步并存储到本地，让数据持久化。

作用

1.容器数据卷有一个数据共享的技术：docker容器中产生的数据，同步并存储到本地。
2.这就是卷技术，目录的挂载，将我们容器内的目录，挂载到主机上。

注意项

1.修改容器内文件时只需在本主机修改对应挂载文件即可，容器内会自动同步。
2.容器间也是可以数据共享的，即多个容器挂载到同一个主机目录下。

总结

容器数据的持久化和同步操作。

命令

创建

创建一个容器卷

docker volume create 卷名

查看

查看所有容器卷

docker volume ls

查看指定容器卷详情

docker volume inspect 卷名

使用

指定挂载（常用）

docker run -v 主机目录:容器内目录

具名挂载：不写主机目录，只写容器卷名，让容器具名挂载到容器卷中。（容器卷不存在会自动创建）

docker run -v 卷名:容器目录

匿名挂载：不写主机目录或容器卷名，让容器内目录匿名挂载到主机。（容器卷docker自动生成）

docker run -v 容器内目录

继承挂载（不常用）：容器c2继承容器c1的挂载配置

docker run c2 --volumes-from c1

ps：匿名挂载和具名挂载的目录都在主机的"/var/lib/docker/volumes/xxx/_data"路径下

权限

只读容器卷（此时这个路径只能通过宿主机操作容器内部无法操作）

docker run -v 主机目录或卷名:容器内目录:ro

可读可写容器卷

docker run -v 主机目录或卷名:容器内目录:rw

二、DockerNetwork

查看容器ip

查看指定容器ip

docker exec -it 容器名 ip addr

容器内查看当前ip

ip addr

link命令

入门

1.连通容器网络（容器B必须已存在）

docker run -d --name 容器A名 --link 容器B名 镜像名:版本

2.测试

docker exec -it 容器A名 ping 容器B名

docker exec -it 容器B名 ping 容器A名

3.此时在容器A里可以ping通容器B，在容器B里可以ping通容器A，两个容器可以互相ping通。

原理

1.分析：进入容器B查看hosts文件

docker exec -it 容器B名 cat /etc/hosts

2.结论

"--link"命令就是在容器hosts配置文件中增加了其他容器的ip映射

ps：这种方式不建议使用太过死板

自定义网络（推荐）

自定义一个网络

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

参数说明：
    --driver bridge			// 网络模式，基于默认网络模式bridge
    --subnet 192.168.0.0/16			// 子网地址，支持192.168.0.2到192.168.255.255
    --gateway 192.168.0.1			// 网关，即路由器地址
    mynet			// 自定义网络模式名

删除自定义网络

docker network rm 网络名

查看网络

查看所有网络模式

docker network ls

网络模式：
    bridge：桥接模式(默认模式)
    none：不配置网络
    host：和主机共享

查看指定网络模式详情

docker network inspect 网络模式名

使用方法

指定容器的网络模式

 docker run -d --name 容器名 --net 网络模式 镜像名:版本

创建容器不指定网络模式时默认使用bridge模式，会自动添加"--net bridge"。
我们自定义的网络模式已经帮我们维护好了对应的关系，推荐开发中使用自定义网络模式。

容器加入指定网络模式

docker network connect 网络模式 容器名或容器id

三、DockerHub

生成镜像

容器生成新镜像

1.容器生成镜像

docker commit -m=描述 -a=用户名 容器id 新镜像名:版本

2.为镜像打tag，必须打tag，否则镜像无法push。打tag时会生成一个新镜像。

docker tag  镜像名:版本  用户名/镜像名:版本

旧镜像生成新镜像

1.下载镜像（本机已存在目标镜像则跳过）

docker pull 原用户名/原镜像名:版本

2.为镜像打tag，打tag时会生成一个新镜像。

docker tag  原用户名/原镜像名:版本  用户名/镜像名:版本

发布镜像

1.注册账号：DockerHub官网注册账号：hub.docker.com/ （已有账号则跳过）

2.登陆账户

docker login -u 用户名

3.发布镜像，提交镜像到DockerHub

docker push 用户名/镜像名:版本

ps：提交镜像时必须在镜像名前加上自己dockerhub的用户名，否则提交错误。

四、拓展

离线镜像

镜像转文件

docker save 镜像名 > /root/image.tar

文件转镜像

docker load < /root/image.tar

docker load -i /root/image.tar

可视化

Docker可视化界面：运行以下命令无报错后可在浏览器输入”主机地址:8080“访问Docker可视化界面

docker run -d -p 8080:9000 \
--ressart=always -v /var/run/docker.sock --privileged=true portainer/portainer

Docker高级

一、dockerFile

（一）入门

1.创建一个dockerfile文件，文件名可自定义。

2.编写dockerfile文件内容，指定命令全部为大写。

FROM centos
VOLUME ["volume01","volume02"]
CMD echo "---上面为匿名挂载---"
CMD /bin/bash

3.将dockerfile构建为一个docker镜像。

docker build -f /dockerfile -t 镜像名:版本

4.运行镜像。

docker run -d --name 容器名 镜像名:版本

（二）常用指令

FROM		 # 基础镜像 一切从这里开始
MAINTAINER	  # 镜像作者
RUN			 # 镜像构建的时候需要运行的命令
ADD			 # 步骤 添加内容
WORKDIR		 # 镜像的工作目录
VOLUME		 # 挂载的目录
EXPOSE		 # 保留端口配置
CMD			 # 指定这个容器启动时运行的命令 只有最后一个命令生效 可被覆盖
ENTRYPOINT    # 指定这个容器启动时运行的命令 可以追加
ONBUILD		 # 构建一个被继承dockerFile
COPY		 # 将文件拷贝到镜像中 类似ADD
ENV			 # 构建时设置环境变量

（三）常用命令

1.查看镜像的构建过程

docker history 镜像id

（四）实战案例

构建一个centos镜像

1.进入home文件夹创建一个dockerFile文件夹

mkdir dockerFile

2.在dockerFile文件夹下创建并编写myDockerFile文件

vi myDockerFile

3.编写mydockerfile文件内容

FROM centos   		   # 镜像内核使用centos最新版
MAINTAINER  tombkeeper  # 镜像作者
ENV MYPATH /usr/local   # 设置环境变量MYPATH
WORKDIR $MYPATH		    # 设置工作路径为环境变量路径
RUN yum -y install vim   # 给镜像下载vim工具
RUN yum -y install net-tools # 给镜像下载net-tools工具
EXPOSE 80  	# 暴露80端口
CMD echo $MYPATH  # 启动时运行$MYPATH
CMD echo "---end---"  # 启动时运行"---end---"
CMD echo /bin/bash    # 启动时运行/bin/bash

4.使用myDockerFile文件构建myCentos镜像

docker build -f myDockerFile -t myCentos:1.0 .

ps：如果myDockerFile文件名为Dockerfile(官方命名)，那么在构建时就无需使用-f指定，docker会自动续找名为Dockerfile的文件。

5.使用myCentos镜像运行容器

docker run -p 8080:80 --name myCentos -d myCentos:1.0

构建一个tomcat镜像

1.进入honme文件夹创建一个dockerFile文件夹

mkdir dockerFile

2.在dockerFile文件夹下创建并编写myTomcat文件

vi tomcatDockerFile

3.编写Dockerfile文件内容

FROM centos
MAINTAINER tombkeeper
COPY readme.txt /usr/local/readme.txt
ADD jdk-16.0.1_linux-x64_bin.tar.gz /usr/local/
ADD apache-tomcat-8.5.69-deployer.tar.gz /usr/local/
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk16.0.1
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.69
ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.69
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-8.5.69/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.69/bin/logs/catalina.out

4.使用tomcatDockerFile文件构建myTomcat镜像

docker build -f tomcatDockerFile -t myTomcat:1.0 .

5.使用tomcat镜像运行容器

docker run -p 9090:8080 --name tomcat01 -v /home/tomcat/test:/usr/local/apache-tomcat-8.5.69/webapps/test -v /home/tomcat/logs:/usr/local/apache-tomcat-8.5.69/logs -d myTomcat

二、DockerCompose

（一）安装

1.下载安装

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

2.配置权限

sudo chmod +x /usr/local/bin/docker-compose

3.查看安装结果

docker-compose version

ps:如果显示版本信息即代表安装成功。

（二）卸载

1.卸载DockerCompose

sudo rm /usr/local/bin/docker-compose

（三）实例：GO程序上线

1.在/home目录下创建my_go文件夹

mkdir /home/my_go

2.进入my_go目录

cd /home/my_go

3.创建main.go文件

vim main.go

3.编写main.go文件内容

package main

import (
	"fmt"
	"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello Golang")
}

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":80", nil)
}

4.创建Dockerfile文件

vim Dockerfile

5.编写Dockerfile文件内容

FROM golang
LABEL maintainer="vczs"
WORKDIR $GOPATH/src/godocker
ADD . $GOPATH/src/godocker
RUN go build main.go
EXPOSE 80
ENTRYPOINT ["./main"]

6.创建"docker-compose.yml"文件

vim docker-compose.yml

7.编写"docker-compose.yml"文件内容

version: '3.8'
services: 
    mygos:
        build: .
        image: mygos

# yaml文件规则
# 参考：https://docs.docker.com/compose/compose-file/compose-file-v3/

8.在/home/my_go目录下使用 "main.go" "Dockerfile" "docker-compose.yml" 三个文件启动程序

docker-compose up --build

9.在主机上检查是否可以访问

curl localhost:8080

10.如果主机上可以访问，此时就可以在本地浏览器输入"ip:8080"访问我们的GO程序。（服务器要开放8080端口）

三、DockerSwarm

（一）入门

1.背景：有至少四台或更多台服务器，要将这些服务器组成一个集群。

2.设置A为主节点（在A服务器上执行）

docker swarm init --advertise-addr A主机ip

3.获取管理身份节点token(只能在主节点获取)

docker swarm join-token manager

4.获取工作身份节点token(只能在主节点获取)

docker swarm join-token worker

5.3和4步骤都会获取一个对应身份的token；其他节点若要加入集群，只需在其终端执行要加入的身份(管理和工作)的token即可。

6.至此集群搭建成功，后续有新服务器要加入集群只需执行token加入即可。

ps：集群主节点应该最少三台；如果双主，其中一个主节点宕机停止，另外一个主节点也不能使用(Raft协议选举规则：最后一个主节点不能自己选举自己)。

（二）常用命令

查看集群节点列表(只能在管理节点查看)

docker node ls

当前主机离开集群

docker swar

Docker实战

一、运行Nginx容器

1.搜索镜像

docker search nginx

2.下载镜像

docker pull nginx

3.运行容器

docker run -d --name nginx01 -p 3355:80 nginx

4.此时就可以在外网通过"主机ip:3355"来访问nginx容器

二、运行tomcat容器

1.搜索镜像

docker search tomcat

2.下载镜像

docker pull tomcat

3.运行容器

docker run -d --name tomcat01 -p 3377:8080 tomcat

4.进入容器

docker exec -it tomcat01 /bin/bash

5.将webapps.dist里的所有文件拷贝到webapps文件夹。（tomcat配置不完整，webapps文件夹里没有部署可运行的文件。）

cp -r webapps.dist/* webapps

6.此时就可以在外网通过"主机ip:3377"来访问nginx容器

三、运行MySQL容器

（一）运行容器

1.搜索镜像

docker search mysql

2.下载镜像

docker pull mysql

3.启动mysql并挂载需要的容器目录到主机

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

4.使用第三方mysql工具连接“ip地址:3306”即可连接mysql

（二）常见问题解决方法

mysql容器自动停止

1.进入与"/etc/mysql/conf.d"挂载的目录，并创建docker.cnf文件。

vi docker.cnf

2.在docker.cnf文件添加如下内容然后保存退出

performance_schema_max_table_instances=400  
table_definition_cache=400  
table_open_cache=256
performance_schema = off

3.重启容器

docker start mysql

四、运行go容器

1.在home/go目录下创建main.go

vi /home/go/main.go

2.编写main.go内容

package main

import (
	"fmt"
	"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello Golang")
}

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":8080", nil)
}

3.在home/go目录下创建Dockerfile文件

vi /home/go/Dockerfile

4.编写Dockerfile内容

# 使用Golang基础镜像
FROM golang:latest
# 设置工作目录
WORKDIR /app
# 复制应用程序代码到容器中
COPY . .
# 构建Go应用程序
RUN go build -o app
# 暴露端口
EXPOSE 8080
# 运行应用程序
CMD ["./app"]

5.进入/home/go目录，使用 "main.go" 和 "Dockerfile" 文件构建镜像。

docker build -t go-app .

6.运行容器

docker run -d -p 8080:8080 --name my-go-app go-app

7.在主机上检查是否可以访问

curl localhost:8080

8.若主机上可以访问，此时就可以在本地浏览器输入"ip:80"访问我们的go项目。（服务器要开放8080端口）

五、运行开源博客

（一）方法一

1.自定义一个网络

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

2.运行mysql容器

docker run -p 3306:3306 --name blog-mysql -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d --net mynet mysql:5.7

3.运行wordpress博客容器

docker run -d --name myblog01 -e WORDPRESS_DB_HOST=blog-mysql -e WORDPRESS_DB_USER=root -e WORDPRESS_DB_PASSWORD=123456 -e WORDPRESS_DB_NAME=blog_db -p 80:80 -p 443:443 --net mynet wordpress

环境变量解释：
WORDPRESS_DB_HOST：数据库地址，填mysql容器名（mysql容器要和开源博客容器在同一个网络模式下，互相可ping通。）
WORDPRESS_DB_USER：mysql用户名，默认root
WORDPRESS_DB_PASSWORD：mysql密码
WORDPRESS_DB_NAME：数据库名

4.浏览器输入“ip:端口”访问并设置个人博客。（请提前在mysql中创建好开源博客的数据库）

5.个人博客搭建成功。

（一）方法二

1.在/home目录下创建一个文件夹，文件名可自定义。

mkdir /home/my_wordpress

2.进入刚创建的空目录

cd /home/my_wordpress

3.创建"docker-compose.yml"文件

vim docker-compose.yml

4.添加"docker-compose.yml"文件内容

version: "3.9"
    
services:
  db:
    image: mysql:5.7
    volumes:
      - db_data:/var/lib/mysql
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: somewordpress
      MYSQL_DATABASE: wordpress
      MYSQL_USER: wordpress
      MYSQL_PASSWORD: wordpress
    
  wordpress:
    depends_on:
      - db
    image: wordpress:latest
    volumes:
      - wordpress_data:/var/www/html
    ports:
      - "8000:80"
    restart: always
    environment:
      WORDPRESS_DB_HOST: db:3306
      WORDPRESS_DB_USER: wordpress
      WORDPRESS_DB_PASSWORD: wordpress
      WORDPRESS_DB_NAME: wordpress
volumes:
  db_data: {}
  wordpress_data: {}

5.运行项目

docker-compose up

6.个人博客搭建成功。

7.停止项目

docker-compose down

其他

typecho博客

1.自定义网络

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

2.运行mysql容器

docker run -p 3306:3306 --name blog-mysql -v /home/mysql/conf.d:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=sun123MM -d --net mynet mysql:5.7

3.运行typecho证书

带证书

docker run -dit -p 80:80 -p 443:443 --name blog -e DOMAIN="vczs.top" -v /home/cert:/etc/nginx/cert vczs/typecho_ssl

"/home/cert"存放证书和密钥
重命名证书和密钥为: typecho.pem 及 typecho.key

不带证书

docker run -d -p 80:80 --name blog --net mynet 80x86/typecho