docker最全笔记速查，逻辑清晰

该笔记总结自狂神docker教程

Hey，我是寅贝勒，后端开发一枚😜,欢迎来我的个人网站 www.ly-zone.cloud 一起学习交流~

---

1.Docker特点

应用更快速的交付和部署
传统：一对帮助文档，安装程序。
Docker：打包镜像发布测试一键运行。

更便捷的升级和扩缩容
使用了 Docker之后，我们部署应用就和搭积木一样
项目打包为一个镜像，扩展服务器A！服务器B

更简单的系统运维
在容器化之后，我们的开发，测试环境都是高度一致的

更高效的计算资源利用

Docker是内核级别的虚拟化，可以在一个物理机上可以运行很多的容器实例！服务器的性能可以被压榨到极致。

2.Docker的安装

①环境准备

linux内核要求3.0以上

//查看内核命令
uname -r
3.10.0-957.21.3.el7.x86_64

//查看完整信息
cat /etc/os-release 

②安装docker

docker docs https://docs.docker.com/engine/install/ （官方文档）

#1.卸载旧版本
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
#2.需要的安装包
yum install -y yum-utils
#3.设置镜像的仓库，默认是从国外的，不推荐
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
#推荐使用国内的
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
#更新yum软件包索引
yum makecache fast
#4.安装docker相关的 docker-ce 社区版 而ee是企业版
yum install docker-ce docker-ce-cli containerd.io
#5、启动docker
systemctl start docker
#6. 使用docker version查看是否按照成功
docker version
#7. 测试
docker run hello-world

③卸载docker

#1. 卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
#2. 删除资源
rm -rf /var/lib/docker
# /var/lib/docker 是docker的默认工作路径！

④配置阿里云镜像加速

1. 登录阿里云找到容器服务
2. 找到镜像加速器
3. 选择对应的centos版本
4. 配置使用

3.常用命令

①帮助命令

docker version    #显示docker的版本信息。
docker info       #显示docker的系统信息，包括镜像和容器的数量
docker 命令 --help #帮助命令

帮助文档的地址：https://docs.docker.com/engine/reference/commandline/build/

②镜像命令

docker images #查看所有本地主机上的镜像 可以使用docker image ls代替

docker search 搜索镜像

docker pull 下载镜像 docker image pull

docker rmi 删除镜像 docker image rm

docker rmi -f 镜像id #删除指定的镜像

docker images -aq ＃显示所有镜像的id

docker rmi -f $(docker images -aq) #删除全部的镜像

③容器命令

**基础命令**
docker run 镜像id #新建容器并启动

docker run -d 镜像名 #以后台方式启动容器

docker run -it 镜像名 /bin/bash #以交互方式启动容器

docker run -d --name 自定义容器名 -p 主机端口：容器端口 镜像名 #启动

docker run -d --name nginx01 -p（-P是随机分配端口） 80:80 nginx

curl localhost:80 #测试连通性

docker exec -it 容器id /bin/bash #以交互方式进入容器（常用）

docker attach 容器id  #进入容器当前的终端（不常用）

docker ps #列出所有运行的容器 docker container list

docker ps -aq #查看所有容器id

docker rm -f 容器id #强制删除指定容器

docker rm -f $(docker ps -aq) #删除所有容器

docker start 容器id #启动容器

docker restart 容器id #重启容器

docker stop 容器id #停止当前正在运行的容器

docker kill 容器id #强制停止当前容器

exit #退出当前容器

ctrl + p + q #容器不停止退出

**进阶命令**
docker logs -t --tail n 容器id #查看n行日志

docker logs -tf 容器id #显示日志信息（一直更新）

docker inspect 容器id #查看容器的元数据

docker #产品容器id：容器内路径 主机目的路径 #从容器内拷贝到主机上

docker stats #查看docker容器使用内存情况

镜像和容器的关系

4.可视化

安装portainer

# Docker图形化界面管理工具！提供一个后台面板供我们操作
docker run -d -p 8080:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

5.Docker镜像加载原理

docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
boots(boot file system）主要包含 bootloader和 Kernel, bootloader主要是引导加 kernel, Linux刚启动时会加bootfs文件系统，在 Docker镜像的最底层是 boots。这一层与我们典型的Linux/Unix系统是一样的，包含boot加載器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由 bootfs转交给内核，此时系统也会卸载bootfs。
rootfs（root file system),在 bootfs之上。包含的就是典型 Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件。 rootfs就是各种不同的操作系统发行版，比如 Ubuntu, Centos等等。

所有的 Docker镜像都起始于一个基础镜像层，当进行修改或培加新的内容时，就会在当前镜像层之上，创建新的镜像层。
举一个简单的例子，假如基于 Ubuntu Linux16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加 Python包，
就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创健第三个镜像层该像当前已经包含3个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。下图中举了一个简单的例子，每个镜像层包含3个文件，而镜像包含了来自两个镜像层的6个文件。

上图中的镜像层跟之前图中的略有区別，主要目的是便于展示文件
下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层中的文件7是文件5的一个更新版

6.提交镜像

docker commit #提交容器成为一个新的副本
# 命令和git原理类似
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]

#实战
# 1、启动一个默认的tomcat
docker run -d -p 8080:8080 tomcat
# 2、发现这个默认的tomcat 是没有webapps应用，官方的镜像默认webapps下面是没有文件的！
docker exec -it 容器id /bin/bash
# 3、拷贝文件进去

# 4、将操作过的容器通过commit调教为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像。
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]
docker commit -a="kuangshen" -m="add webapps app" 容器id tomcat02:1.0

7.数据卷

三种挂载方式： 匿名挂载、具名挂载、指定路径挂载

-v 容器内路径			#匿名挂载
-v 卷名：容器内路径		#具名挂载
-v /宿主机路径：容器内路径 #指定路径挂载 docker volume ls 是查看不到的

指定路径挂载

-v, --volume list                   双向绑定

docker run -it -v 主机目录:容器内目录  -p 主机端口:容器内端口

docker run -it -v /home/ceshi:/home/centos /bin/bash

#通过 docker inspect 容器id 查看，可以在Mounts中看到挂载的卷

Mysql实战

# 获取mysql镜像
docker pull mysql:5.7

# 参考官网hub 
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

#启动
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
-- name 容器名字

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

# 启动成功之后，我们在本地使用sqlyog来测试一下
# sqlyog-连接到服务器的3306--和容器内的3306映射 
# 在本地测试创建一个数据库，查看一下我们映射的路径是否ok！

具名和匿名挂载

# 匿名挂载
-v 容器内路径!
docker run -d -P --name nginx01 -v /etc/nginx nginx

# 查看所有的volume的情况
docker volume ls    

DRIVER              VOLUME NAME
local               33ae588fae6d34f511a769948f0d3d123c9d45c442ac7728cb85599c2657e50d
            
# 这种就是匿名挂载，-v只写了容器内的路径，没有写容器外的路径

# 具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

docker volume ls   
               
DRIVER              VOLUME NAME
local               juming-nginx

# 通过 -v 卷名：容器内路径
# 查看一下这个卷,可以查看挂载点

docker volume inspect juming-nginx

所有的docker容器内的卷，没有指定目录的情况下都是在在/var/lib/docker/volumes/xxxx/_data下
如果指定了目录，docker volume ls 是查看不到的

拓展

# 通过 -v 容器内路径： ro rw 改变读写权限
ro #readonly 只读
rw #readwrite 可读可写，默认
docker run -d -P --name nginx05 -v juming:/etc/nginx:ro nginx
docker run -d -P --name nginx05 -v juming:/etc/nginx:rw nginx
# ro 只要看到ro就说明这个路径只能通过宿主机来操作，容器内部是无法操作！

数据卷容器

--volumes-from 容器id
mysql02 挂载到 mysql01上
              
docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

docker run -d -p 3307:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01  mysql:5.7
# 这个时候，可以实现两个容器数据同步

容器之间的配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止，但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的

8.Dockerfile

Dockerfile 就是用来构建docker镜像的构建文件

# 创建一个dockerfile文件，名字可以随便 建议Dockerfile
# 文件中的内容 指令(大写) 参数
FROM centos

VOLUME ["volume01","volume02"]		#匿名挂载

CMD echo "----end----"
CMD /bin/bash
#这里的每个命令，就是镜像的一层！

#打包镜像
docker build -f /home/docker/dockerfile -t  ly/centos:1.0

①步骤

1. 编写一个dockerfile文件
2. docker build 构建称为一个镜像
3. docker run运行镜像
4. docker push发布镜像（DockerHub 、阿里云仓库)

# 测试 启动3个容器，通过刚才自己写的镜像启动
docker run -it --name docker01 ly/centos:1.0

# 查看容器docekr01内容
ls
bin  home   lost+found	opt   run   sys  var
dev  lib    media	proc  sbin  tmp  volume01
etc  lib64  mnt		root  srv   usr  volume02

# 不关闭该容器退出
CTRL + Q + P  

# 创建docker02: 并且让docker02 继承 docker01
docker run -it --name docker02 --volumes-from docker01 ly/centos:1.0

# 查看容器docker02内容
ls
bin  home   lost+found	opt   run   sys  var
dev  lib    media	proc  sbin  tmp  volume01
etc  lib64  mnt		root  srv   usr  volume02

# 再新建一个docker03同样继承docker01
docker run -it --name docker03 --volumes-from docker01 ly/centos:1.0
cd volume01	#进入volume01 查看是否也同步docker01的数据
ls 
docker01.txt

测试：可以删除docker01，查看一下docker02和docker03是否可以访问这个文件
测试发现：数据依旧保留在docker02和docker03中没有被删除

②基础知识

1. 每个保留关键字(指令）都是必须是大写字母
2. 执行从上到下顺序
3. #表示注释
4. 每一个指令都会创建提交一个新的镜像层，并提交
   

③DockerFile的指令

FROM				# from:基础镜像，一切从这里开始构建
MAINTAINER			# maintainer:镜像是谁写的， 姓名+邮箱
RUN					# run:镜像构建的时候需要运行的命令
ADD					# add:步骤，tomcat镜像，这个tomcat压缩包！添加内容 添加同目录
WORKDIR				# workdir:镜像的工作目录
VOLUME				# volume:挂载的目录
EXPOSE				# expose:保留端口配置
CMD					# cmd:指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT			# entrypoint:指定这个容器启动的时候要运行的命令，可以追加命令
ONBUILD				# onbuild:当构建一个被继承DockerFile这个时候就会运行onbuild的指令，触发指令
COPY				# copy:类似ADD，将我们文件拷贝到镜像中
ENV					# env:构建的时候设置环境变量！

④实战，创建自己的centos

# 1.编写Dockerfile文件
vim mydockerfile-centos

FROM centos
MAINTAINER ly<578104130@qq.com>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "-----end----"
CMD /bin/bash

# 2、通过这个文件构建镜像
# 命令 docker build -f 文件路径 -t 镜像名:[tag] .
docker build -f mydockerfile-centos -t mycentos:0.1 .

CMD 和 ENTRYPOINT区别

CMD					# 指定这个容器启动的时候要运行的命令，只有最后一个会生效，可被替代。
ENTRYPOINT			# 指定这个容器启动的时候要运行的命令，可以追加命令

⑤实战，创建自己的tomcat

1.准备好tomcat和jdk的压缩包，编写好readme文件

2.编写dockerfile

FROM centos #
MAINTAINER ly<578104130@qq.com>
COPY README /usr/local/README #复制文件
ADD jdk-8u231-linux-x64.tar.gz /usr/local/ #复制解压
ADD apache-tomcat-9.0.35.tar.gz /usr/local/ #复制解压
RUN yum -y install vim
ENV MYPATH /usr/local #设置环境变量
WORKDIR $MYPATH #设置工作目录
ENV JAVA_HOME /usr/local/jdk1.8.0_231 #设置环境变量
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35 #设置环境变量
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib #设置环境变量 分隔符是：
EXPOSE 8080 #设置暴露的端口
CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.35/logs/catalina.out # 设置默认命令

3.构建镜像

# 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件
$ docker build -t mytomcat:0.1 .

4.run镜像

$ docker run -d -p 8080:8080 --name tomcat01 -v /home/kuangshen/build/tomcat/test:/usr/local/apache-tomcat-9.0.35/webapps/test -v /home/kuangshen/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.35/logs mytomcat:0.1

⑥发布自己的镜像

发布在Dockerhub上

1.地址 https://hub.docker.com
2.登录

docker login --help
Usage:  docker login [OPTIONS] [SERVER]

Log in to a Docker registry.
If no server is specified, the default is defined by the daemon.

Options:
  -p, --password string   Password
      --password-stdin    Take the password from stdin
  -u, --username string   Username

docker login -u ly1023 -p xxxx

3.push镜像

docker tag 镜像id ly1023/ly/mytomcat:1.0

docker push ly1023/ly/mytomcat:1.0

发布在阿里云镜像服务上
官网 https://cr.console.aliyun.com/repository/

sudo docker images
REPOSITORY                                                         TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
registry.aliyuncs.com/acs/agent                                    0.7-dfb6816         37bb9c63c8b2        7 days ago          37.89 MB

sudo docker tag 37bb9c63c8b2 registry-vpc.cn-hangzhou.aliyuncs.com/acs/agent:0.7-dfb6816

sudo docker push registry-vpc.cn-hangzhou.aliyuncs.com/acs/agent:0.7-dfb6816

⑦图解

9.Docker网络（Docker0）

我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要安装了docker，就会有一个docker0桥接模式，使用的技术是veth-pair技术，每启动一个docker就多一对地址

①veth-pair

veth-pair 就是一对的虚拟设备接口，和 tap/tun 设备不同的是，它都是成对出现的。一端连着协议栈，一端彼此相连着。
正因为有这个特性 veth-pair 充当一个桥梁，连接各种虚拟网络设备的
OpenStack,Docker容器之间的连接，OVS的连接，都是使用evth-pair技术

Docker使用的是Linux的桥接，宿主机是一个Docker容器的网桥 docker0

Docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）,只要容器删除，对应的一对网桥就没有了

②使用–link

本质是在节点的host文件中添加其他节点的ip（不建议使用）

docker exec -it tomcat02 ping tomca01   # ping不通


# 运行一个tomcat03 --link tomcat02 
docker run -d -P --name tomcat03 --link tomcat02 tomcat

# 用tomcat03 ping tomcat02 可以ping通
docker exec -it tomcat03 ping tomcat02

# 用tomcat02 ping tomcat03 ping不通

docker network inspect 网络id

③自定义网络

docker network
connect     -- Connect a container to a network
create      -- Creates a new network with a name specified by the
disconnect  -- Disconnects a container from a network
inspect     -- Displays detailed information on a network
ls          -- Lists all the networks created by the user
prune       -- Remove all unused networks
rm          -- Deletes one or more networks

#查看所有网络
docker network ls

网络模式

1. bridge ：桥接 docker（默认，自己创建也是用bridge模式）
2. none ：不配置网络，一般不用
3. host ：和所主机共享网络
4. container ：容器网络连通（用得少，局限很大）

# 我们直接启动的命令 --net bridge,而这个就是我们的docker0
# bridge就是docker0
docker run -d -P --name tomcat01 tomcat
等价于 => 
docker run -d -P --name tomcat01 --net bridge tomcat

# docker0，特点：默认，域名不能访问
# --link可以打通连接，但是很麻烦！
# 自定义一个网络
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

docker network inspect mynet;

假设要跨网络操作别人，就需要使用docker network connect 连通

# 将tomcat01加入到mynet网络中
docker network connect mynet tomcat01
#进行测试
docker exec tomcat-net-01 ping tomcat01

10.实战：部署Redis集群

# 创建网卡，默认是桥接模式
docker network create redis --subnet 172.38.0.0/16

# 通过脚本创建六个redis配置
for port in $(seq 1 6);\
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >> /mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

# 通过脚本运行六个redis
for port in $(seq 1 6);\
do \
docker run -p 637${port}:6379 -p 1667${port}:16379 --name redis-${port} \
-v /mydata/redis/node-${port}/data:/data \
-v /mydata/redis/node-${port}/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.1${port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
done

docker exec -it redis-1 /bin/sh #redis默认没有bash

redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379  --cluster-replicas 1

#退出后下次进入
docker exec -it redis-1 /bin/sh
redis-cli -c

11.SpringBoot微服务打包docker镜像

1. 构建springboot项目
2. 打包成jar包
3. 在jar包所在的文件夹中编写dockerfile

FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]

4. 构建镜像

# 1.复制jar和DockerFIle到服务器
# 2.构建镜像
$ docker build -t springbootdocker:1.0  .

5. 发布运行，可发布到dockerhub、阿里容器服务以及本地拷贝

更多技术博客、答疑、交流，欢迎关注我的微信公众号~