基础教程

帮助命令

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

镜像命令

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

容器命令

docker pull #下载镜像 docker image pull
docker rmi #删除镜像 docker image rm
docker images
docker images -a  #列出所有镜像详细信息
docker images -aq #列出所有镜像的id
docker search mysql #查询网上的mysql的镜像 
#  --filter=STARS=3000 #过滤，搜索出来的镜像收藏STARS数量大于3000的
#等价于
docker pull tomcat:8
docker pull docker.io/library/tomcat:8
docker rmi -f 镜像id #删除指定id的镜像
docker rmi -f $(docker images -aq) #删除全部的镜像
docker stop $(docker ps -a -q) #停止所有的容器
docker pull centos        #docker中下载centos
docker run 镜像id         #新建容器并启动
docker container list -a  # 查看所有的容器
docker ps -a              # 查看所有的容器
docker rm 容器id          #删除指定容器
docker start 容器id          #启动容器
docker restart 容器id     #重启容器
docker stop 容器id          #停止当前正在运行的容器
docker kill 容器id          #强制停止当前容器

docker run [可选参数] image | docker container run [可选参数] image 
#参书说明
--name="Name"        #容器名字 tomcat01 tomcat02 用来区分容器
-d                    #后台方式运行
-it                 #使用交互方式运行，进入容器查看内容
-p                    #指定容器的端口 -p 8080(宿主机):8080(容器)
        -p ip:主机端口:容器端口
        -p 主机端口:容器端口(常用)
        -p 容器端口
        容器端口
-P(大写)                 随机指定端口

docker run -it centos /bin/bash # 测试、启动并进入容器
exit #从容器退回主机
docker ps 命令          #列出当前正在运行的容器 还没退出的（exit）
  -a, --all          #列出当前正在运行的容器 + 带出历史运行过的容器
  -n=?, --last int   #列出最近创建的?个容器 ?为1则只列出最近创建的一个容器,为2则列出2个
  -q, --quiet        #只列出容器的编号

退出容器

exit         #容器直接退出
ctrl +P +Q  #容器不停止退出     ---注意：这个很有用的操作

删除容器

docker rm 容器id                   #删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm -rf
docker rm -f $(docker ps -aq)       #删除所有的容器
docker ps -a -q|xargs docker rm  #删除所有的容器

后台启动

docker run -d centos #这都是看不到信息的
# 问题docker ps. 发现centos 停止了
# 常见的坑，docker容器使用后台运行，就必须要有要一个前台进程，docker发现没有应用，就会自动停止
# nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了

日志查看

docker logs --help
Options:
      --details        Show extra details provided to logs 
*  -f, --follow         Follow log output
      --since string   Show logs since timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)
*      --tail string    Number of lines to show from the end of the logs (default "all")
*  -t, --timestamps     Show timestamps
      --until string   Show logs before a timestamp (e.g. 2013-01-02T13:23:37) or relative (e.g. 42m for 42 minutes)
➜  ~ docker run -d centos /bin/sh -c "while true;do echo 6666;sleep 1;done" #模拟日志      
#显示日志
-tf        #显示日志信息（一直更新）
--tail number #需要显示日志条数
docker logs -t --tail n 容器id #查看n行日志
docker logs -ft 容器id #跟着日志

容器进程

#查看容器中进程信息ps
docker top 容器id

查看元数据

docker inspect 容器id
docker inspect 镜像id

进入容器

# 方式一
# 进入当前正在运行的容器
docker exec -it 容器id bash shell
# 方式二
docker attach 容器id
#测试
docker attach 55321bcae33d 
正在执行当前的代码...
区别
#docker exec #进入当前容器后开启一个新的终端，可以在里面操作。（常用）
#docker attach # 进入容器正在执行的终端

拷贝命令

#先进入到容器中
docker exec -it 56a5583b25b4 /bin/bash
#再创建一个新文件
echo "hello" > hello.java # "hello"是内容 hello.java是文件名（souce命令用不了）
#测试文件是否存在了
cat hello.java 
#将容器中的文件拷贝到主机上
# docker cp 容器名:容器内文件 主机上的路径
docker cp 9035020356a4:/java.java /home

实例：docker安装Nginx

# 这种绑定宿主机端口的 是可以后台运行的 不会自动关闭
# -d 后台运行
# --name 给容器命名
# -p 宿主机端口：容器内部端口
docker run -d --name nginx01 -p 3344:80 nginx
docker exec -it nginx01 /bin/bash #进入容器 可用name进入e
whereis nginx    #找到nginx位置
# 跟宿主机绑定端口之后 之前ps start restart都可以使用测试了

实例2：docker安装tomcat

#以后台方式，暴露端口方式，启动运行
docker run -d -p 8080:8080 --name tomcat01 tomcat
#默认tomcat——》webapp没有可执行文件 可将webapp.dist下的文件复制到 webapps下
cp -r webapps.dist/ webapps
# 确保服务器的端口号开启 8080
#测试访问有没有问题
curl localhost:8080

commit镜像

"这样新增的副本比下下来的 镜像 强 有你增加的额外的功能"
docker commit 提交容器成为一个新的副本
# 命令和git原理类似
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[版本TAG]
# 1、启动一个默认的tomcat
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker run -d -p 8080:8080 tomcat
de57d0ace5716d27d0e3a7341503d07ed4695ffc266aef78e0a855b270c4064e
# 2、发现这个默认的tomcat 是没有webapps应用，官方的镜像默认webapps下面是没有文件的！
#docker exec -it 容器id /bin/bash
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker exec -it de57d0ace571 /bin/bash
root@de57d0ace571:/usr/local/tomcat# 
# 3、从webapps.dist拷贝文件进去webapp
root@de57d0ace571:/usr/local/tomcat# cp -r webapps.dist/* webapps
root@de57d0ace571:/usr/local/tomcat# cd webapps
root@de57d0ace571:/usr/local/tomcat/webapps# ls
ROOT  docs  examples  host-manager  manager
# 4、将操作过的容器通过commit调教为一个镜像！我们以后就使用我们修改过的镜像即可，而不需要每次都重新拷贝webapps.dist下的文件到webapps了，这就是我们自己的一个修改的镜像。
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]
docker commit -a="kuangshen" -m="add webapps app" 容器id tomcat02:1.0
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker commit -a="csp提交的" -m="add webapps app" de57d0ace571 tomcat02.1.0
sha256:d5f28a0bb0d0b6522fdcb56f100d11298377b2b7c51b9a9e621379b01cf1487e
[root@iz2zeak7sgj6i7hrb2g862z ~]# docker images
REPOSITORY            TAG                 IMAGE ID            CREATED             SIZE
tomcat02.1.0          latest              d5f28a0bb0d0        14 seconds ago      652MB
tomcat                latest              1b6b1fe7261e        5 days ago          647MB
nginx                 latest              9beeba249f3e        5 days ago          127MB
mysql                 5.7                 b84d68d0a7db        5 days ago          448MB
elasticsearch         7.6.2               f29a1ee41030        8 weeks ago         791MB
portainer/portainer   latest              2869fc110bf7        2 months ago        78.6MB
centos                latest              470671670cac        4 months ago        237MB
hello-world           latest              bf756fb1ae65        4 months ago        13.3kB

进阶教程

数据挂载

直接使用命令挂载 -v

-v, --volume list             Bind mount a volume
docker run -it -v 主机目录:容器内目录  -p 主机端口:容器内端口
# /home/ceshi：主机home目录下的ceshi文件夹  映射：centos容器中的/home
docker run -it -v /home/ceshi:/home centos /bin/bash
#这时候主机的/home/ceshi文件夹就和容器的/home文件夹关联了,二者可以实现文件或数据同步了
#通过 docker inspect 容器id 查看
docker inspect 6064c490c371
#这是查看容器的信息的 Mounts就是挂载的信息
"Mounts": [
            {
                "Type": "bind",
                "Source": "/home/ceshi", #本地
                "Destination": "/home",  #容器
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],

再来测试！
1、停止容器
2、宿主机修改文件
3、启动容器
4、容器内的数据依旧是同步的
好处：我们以后修改只需要在本地修改即可，容器内会自动同步！

实例：安装mysql并挂载数据

# 获取mysql镜像
docker pull mysql:5.7
# 运行容器,需要做数据挂载 #安装启动mysql，需要配置密码的，这是要注意点！
# 参考官网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 3310:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql03 mysql:5.7
# 启动成功之后，我们在本地使用sqlyog来测试一下
# sqlyog-连接到服务器的3306--和容器内的3306映射 
# 在本地测试创建一个数据库，查看一下我们映射的路径是否ok！

假设我们将包含mysql的容器删除时，
发现，我们挂载到本地的数据卷依旧没有丢失，这就实现了容器数据持久化功能。

具名挂载、匿名挂载

# 匿名挂载
-v 容器内路径!
docker run -d -P --name nginx01 -v /etc/nginx nginx
# 查看所有的volume(卷)的情况
$ docker volume ls    
DRIVER              VOLUME NAME # 容器内的卷名(匿名卷挂载)
local               21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
local               b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c
# 这里发现，这种就是匿名挂载，我们在 -v只写了容器内的路径，没有写容器外的路径！
# 具名挂载 -P:表示随机映射端口
$ docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx
9663cfcb1e5a9a1548867481bfddab9fd7824a6dc4c778bf438a040fe891f0ee
# 查看所有的volume(卷)的情况
$ docker volume ls                  
DRIVER              VOLUME NAME
local               21159a8518abd468728cdbe8594a75b204a10c26be6c36090cde1ee88965f0d0
local               b17f52d38f528893dd5720899f555caf22b31bf50b0680e7c6d5431dbda2802c
local               juming-nginx #多了一个名字
# 通过 -v 卷名：查看容器内路径
# 查看一下这个卷
$ docker volume inspect juming-nginx
[
    {
        "CreatedAt": "2020-05-23T13:55:34+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data", #默认目录
        "Name": "juming-nginx",
        "Options": null,
        "Scope": "local"
    }
]
" 所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/自定义的卷名/_data下，
如果指定了目录，docker volume ls 是查看不到的。"

三种挂载方式区别

# 三种挂载： 匿名挂载、具名挂载、指定路径挂载
-v 容器内路径            #匿名挂载
-v 卷名：容器内路径          #具名挂载
-v /宿主机路径：容器内路径 #指定路径挂载 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就说明这个路径只能通过宿主机来操作，容器内部是无法操作！

Dockerfile

是用来构建docker镜像的文件！命令参数脚本！

构建步骤：

1、 编写一个dockerfile文件
2、 docker build 构建称为一个镜像
3、 docker run运行镜像
4、 docker push发布镜像（DockerHub 、阿里云仓库)
网上的DockerFile很多
很多官方镜像都是基础包，很多功能没有，我们通常会自己搭建自己的镜像！

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./home下新建dockerfile目录
mkdir dockerfile
# 2. dockerfile目录下新建mydockerfile-centos文件
vim mydockerfile-centos
# 3.编写Dockerfile配置文件
FROM centos                            # 基础镜像是官方原生的centos
MAINTAINER fu<1@qq.com>     # 作者
ENV MYPATH /usr/local                # 配置环境变量的目录 
WORKDIR $MYPATH                        # 将工作目录设置为 MYPATH
RUN yum -y install vim                # 给官方原生的centos 增加 vim指令
RUN yum -y install net-tools        # 给官方原生的centos 增加 ifconfig命令
EXPOSE 80                            # 暴露端口号为80
CMD echo $MYPATH                    # 输出下 MYPATH 路径
CMD echo "-----end----"                
CMD /bin/bash                        # 启动后进入 /bin/bash
# 4.通过这个文件构建镜像
# 命令： docker build -f 文件路径 -t 镜像名:[tag] .
$ docker build -f mydockerfile-centos -t mycentos:0.1 .
$ docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mycentos            0.1                 cbf5110a646d        2 minutes ago       311MB
# 6.测试运行
docker run -it mycentos:0.1         # 注意带上版本号，否则每次都回去找最新版latest
pwd    
/usr/local                            # 与Dockerfile文件中 WORKDIR 设置的 MYPATH 一致
vim                                # vim 指令可以使用
ifconfig                             # ifconfig 指令可以使用
# docker history 镜像id 查看镜像构建历史步骤
docker history 镜像id

ENV和ENENTRYPOINT区别

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

实战Tomcat镜像

#如果dockerfile是dockerfile build的时候就不需要输入文件名 默认就是dockerfile
vim dockerfile
FROM centos                                         # 基础镜像centos
MAINTAINER cao<1165680007@qq.com>                    # 作者
COPY README /usr/local/README                         # 复制README文件
ADD jdk-8u231-linux-x64.tar.gz /usr/local/             # 添加jdk，ADD 命令会自动解压
ADD apache-tomcat-9.0.35.tar.gz /usr/local/         # 添加tomcat，ADD 命令会自动解压
RUN yum -y install vim                                # 安装 vim 命令
ENV MYPATH /usr/local                                 # 环境变量设置 工作目录
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_231                 # 环境变量： JAVA_HOME环境变量
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35     # 环境变量： tomcat环境变量
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.35
# 设置环境变量 分隔符是：
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin     
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                     # 设置默认命令
# 构建镜像
# 因为dockerfile命名使用默认命名 因此不用使用-f 指定文件
$ docker build -t mytomcat:0.1 .
# 运行镜像
# -d:后台运行 -p:暴露端口 --name:别名 -v:绑定路径 
$ docker run -d -p 8080:8080 --name tomcat01 
-v /home/tomcat/test:/usr/local/apache-tomcat-9.0.35/webapps/test 
-v /home/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.35/logs mytomcat:0.1
# 测试访问
$ docker exec -it 自定义容器的id /bin/bash
$ cul localhost:8080

Docker网络

理解Docker 0
学习之前清空下前面的docker 镜像、容器

# 删除全部容器
$ docker rm -f $(docker ps -aq)
# 删除全部镜像
$ docker rmi -f $(docker images -aq)
# 查看地址 可看见地址的使用情况
ip addr
# 最下面肯定是自己创建的
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 00:16:3e:09:3d:27 brd ff:ff:ff:ff:ff:ff
    inet 172.16.25.125/20 brd 172.16.31.255 scope global dynamic noprefixroute eth0
       valid_lft 299906777sec preferred_lft 299906777sec
3: docker0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default
    link/ether 02:42:5a:5a:30:41 brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
59: veth49a5c33@if58: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue master docker0 state UP group default
    link/ether de:4d:2c:c0:4a:52 brd ff:ff:ff:ff:ff:ff link-netnsid 0

docker 是如果处理容器网络访问的？（容器跟容器的网络通信）

# 测试  运行一个tomcat
$ docker run -d -P --name tomcat01 tomcat
# 查看容器内部网络地址
$ docker exec -it 容器id ip addr
# 发现容器启动的时候会得到一个 eth0@if91 ip地址，docker分配！
$ ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
261: eth0@if91: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.18.0.2/16 brd 172.18.255.255 scope global eth0
       valid_lft forever preferred_lft forever
# 思考？ linux能不能ping通容器内部！ 可以 容器内部可以ping通外界吗？ 可以！
$ ping 172.18.0.2
PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.069 ms
64 bytes from 172.18.0.2: icmp_seq=2 ttl=64 time=0.074 ms

我们每启动一个docker容器，docker就会给docker容器分配一个ip，我们只要按照了docker，就会有一个docker0桥接模式，使用的技术是veth-pair技术！

我们来测试下tomcat01和tomcat02是否可以ping通

ip可以 名字不行

# 创建两个tomcat
# 获取tomcat01的ip 172.17.0.2
$ docker-tomcat docker exec -it tomcat01 ip addr  
550: eth0@if551: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default 
    link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
    inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
       valid_lft forever preferred_lft forever
# 让tomcat02 ping tomcat01       
$ docker-tomcat docker exec -it tomcat02 ping 172.17.0.2
PING 172.17.0.2 (172.17.0.2) 56(84) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.098 ms
64 bytes from 172.17.0.2: icmp_seq=2 ttl=64 time=0.071 ms
# 结论：容器和容器之间是可以互相ping通 ip是可以ping通的 但是ping 容器名称就不行了

小节

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

Docker中所有网络接口都是虚拟的，虚拟的转发效率高（内网传递文件）

只要容器删除，对应的网桥一对就没了！

如何通过名字来进行访问容器？

Link

docker exec -it tomcat02 ping tomca01   # ping不通 注意上面ping ip是可以的
#结果
ping: tomca01: Name or service not known
# 运行一个tomcat03 --link tomcat02 
docker run -d -P --name tomcat03 --link tomcat02 tomcat
5f9331566980a9e92bc54681caaac14e9fc993f14ad13d98534026c08c0a9aef
# 3连接2
# 用tomcat03 ping tomcat02 可以ping通
# 这种命令是不进入docker里面运行一些命令
[root@lisen ~]# docker exec -it tomcat03 ping tomcat02
PING tomcat02 (172.17.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.17.0.3): icmp_seq=1 ttl=64 time=0.124 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.071 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.078 ms
# 2连接3
# 用tomcat02 ping tomcat03 ping不通
[root@lisen ~]# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known
# 这说明这个link是单向的A --link b a就能ping通b

原理

docker inspect tomcat03 #可查看网络id
docker network inspect 网络id # 网段相同 都一样
"Containers": {
            "da8e64ff0cff7cc5fb972e6378e5bdbe754b650087309287430f3f1da1745189": {
                "Name": "tomcat02",
                "EndpointID": "dce022ed437d228f912436423e806add7dac9431b02d81a5d59417091597988c",
                "MacAddress": "02:42:ac:11:00:03",
                "IPv4Address": "172.17.0.3/16",
                "IPv6Address": ""
            },
            "ed2dde073b32d62424372bc8cc71355873bac3da56bcc89aa0acc2c95a78cb26": {
                "Name": "tomcat01",
                "EndpointID": "3a3a8a52450c1f75c325ed69b5620e28b6d8371e3190f9fae2a4569a43817f7d",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            },
            "f0bfe130592b16b9e8abd017eeef2466cc0bfed78cfa3847a8db02c313688fcd": {
                "Name": "tomcat03",
                "EndpointID": "742b907691b7387a51762bc417d7ac8957e0b33b39a283d990e96ae84cf489c1",
                "MacAddress": "02:42:ac:11:00:04",
                "IPv4Address": "172.17.0.4/16",
                "IPv6Address": ""
            }
        },
# 可查看links的信息
docker inspect tomcat03
"Links": [
        "/tomcat02:/tomcat03/tomcat02"
    ],
# docker02 是没有的 单向的
# 查看tomcat03里面的/etc/hosts发现有tomcat02的配置
[root@lisen ~]# docker exec tomcat03 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
172.17.0.3    tomcat02 da8e64ff0cff
172.17.0.4    f0bfe130592b

–link 本质就是在hosts配置中添加映射
现在使用Docker已经不建议使用–link了！
自定义网络，不适用docker0！
docker0问题：不支持容器名连接访问！

自定义网络

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网络

[root@lisen ~]# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
06402e764161        bridge              bridge              local
14fe54efd95e        host                host                local
8988d4414cb5        none                null                local

网络模式

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

  我们直接启动的命令 —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

查看网络的 有刚才自定义的mynet

[root@lisen ~]# docker network ls NETWORK ID NAME DRIVER SCOPE 06402e764161 bridge bridge local 14fe54efd95e host host local 74a7c0f53818 mynet bridge local 8988d4414cb5 none null local

查看mynet的信息

[root@lisen ~]# docker network inspect mynet [ { “Name”: “mynet”, “Id”: “74a7c0f53818c5a85a8298d570c8d8e811f27a3410188333c1c02c02d9c78711”, “Created”: “2020-09-03T14:33:31.928887101+08:00”, “Scope”: “local”, “Driver”: “bridge”, “EnableIPv6”: false, “IPAM”: { “Driver”: “default”, “Options”: {}, “Config”: [ { “Subnet”: “192.168.0.0/16”, “Gateway”: “192.168.0.1” } ] }, “Internal”: false, “Attachable”: false, “Ingress”: false, “ConfigFrom”: { “Network”: “” }, “ConfigOnly”: false, “Containers”: {}, “Options”: {}, “Labels”: {} } ]

```bash
# 创建两个tomcat容器 用mynet
[root@lisen ~]# docker run -d -P --name tomcat-net-01 --net mynet tomcat:9.0.37
[root@lisen ~]# docker run -d -P --name tomcat-net-02 --net mynet tomcat:9.0.37
# 这是现在mynet的信息 Containers多了两个信息
[root@lisen ~]# docker network inspect mynet
[
    {
        "Name": "mynet",
        "Id": "74a7c0f53818c5a85a8298d570c8d8e811f27a3410188333c1c02c02d9c78711",
        "Created": "2020-09-03T14:33:31.928887101+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.0.0/16",
                    "Gateway": "192.168.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Ingress": false,
        "ConfigFrom": {
            "Network": ""
        },
        "ConfigOnly": false,
        "Containers": {
            "adb7513f0131ea6a0618c39b87254f9fad6306592b2eabceb06346137f40ac5b": {
                "Name": "tomcat-net-02",
                "EndpointID": "63c2cf7f8999cf3e17703f4dfd26ea4eb39ae61341824207ed0cd5fd8d40e181",
                "MacAddress": "02:42:c0:a8:00:03",
                "IPv4Address": "192.168.0.3/16",
                "IPv6Address": ""
            },
            "cd335df7ea4ca079d66855ff3156f319c5b9b497d1169ebaca14b06a5274cd88": {
                "Name": "tomcat-net-01",
                "EndpointID": "2cf1de0625c7c60a0b84c1fe0d132afeea260a40fece11ee181a2cd23f94c407",
                "MacAddress": "02:42:c0:a8:00:02",
                "IPv4Address": "192.168.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {},
        "Labels": {}
    }
]
#测试两者之间是否可以互相ping通 是可以的
[root@lisen ~]# docker exec tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.104 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.090 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.101 ms
[root@lisen ~]# docker exec tomcat-net-02 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.075 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.085 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.092 ms

SpringBoot微服务打包Docker镜像

FROM java:8
COPY *.jar /app.jar
CMD ["--server.port=8080"]
EXPOSE 8080
ENTRYPOINT ["java","-jar","app.jar"]
# 1.复制jar和DockerFIle到服务器
# 2.构建镜像
$ docker build -t xxxxx:xx  .

docker-compose

安装

1、下载
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
2、授权
$ sudo chmod +x /usr/local/bin/docker-compose
3、创建软连接，方便全局调用
$ sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
4、测试是否安装成功
$ docker-compose --version
cker-compose version 1.24.1, build 4667896b

Docker-Compose管理MySQL和Tomcat容器

yml文件以key:value方式指定配置信息 多个配置信息以换行+缩进的方式来区分 docker-compose.yml文件中，不要使用制表符 关键词：后面都是有一个空格的，比如：restart: always

以一个管理mysql+tomcat的yaml的容器为例

version:'3.1'
services:
  mysql:                     # 服务的名称
    restart: always          # 代表只要Docker启动，那么这个容器就跟着一起启动
    image: daocloud.io/library/mysql:5.7.4     # 指定镜像路径
    container_name: mysql    # 指定容器名称
    ports:
      - 3306:3306        # 指定端口号的映射
    environment:
      MYSQL_ROOT_PASSWORD: root         # 指定MySQL的ROOT用户登录密码
      TZ: Asia/Shanghai                 # 指定时区
    volumes:
      - /opt/docker_mysql-tomcat/mysql_data:/var/lib/mysql        # 映射数据卷
  tomcat:
    restart: always          # 代表只要Docker启动，那么这个容器就跟着一起启动
    image: daocloud.io/library/tomcat:8.5.15-jre8     # 指定镜像路径
    container_name: tomcat    # 指定容器名称
    ports:
      - 8080:8080        # 指定端口号的映射
    environment:
      MYSQL_ROOT_PASSWORD: root         # 指定MySQL的ROOT用户登录密码
      TZ: Asia/Shanghai                 # 指定时区
    volumes:
      - /opt/docker_mysql-tomcat/tomcat_webapps:/usr/local/tomcat/webapps        # 映射数据卷
      - /opt/docker_mysql-tomcat/tomcat_logs:/usr/local/tomcat/logs        # 映射数据卷

常用命令

 # 1. 基于docker-compose.yml启动管理的容器
docker-compose up -d
# 2. 关闭并删除容器
docker-compose down
# 3. 开启|关闭|重启已经存在的由docker-compose维护的容器
docker-compose start|stop|restart
# 4. 查看由docker-compose管理的容器
docker-compose ps
# 5. 查看日志
docker-compose logs -f

docker-compose配合Dockerfile使用

使用docker-compose.yml文件以及Dockerfile文件在生成自定义镜像的同时启动当前镜像，并且由docker-compose去管理容器
docker-compose.yml：

# yml文件
version: '3.1'
services:
  ssm:
    restart: always
    build:                           # 构建自定义镜像
      context: ../                   # 指定Dockerfile文件所在路径
      dockerfile: Dockerfile         # 指定Dockerfile文件名称
    image: ssm:1.0.1
    container_name: ssm
    ports:
      8081:8080
    environment:
      TZ: Asia/Shanghai