一、简介

1.1 相关地址

• Docker是基于Go语言开发的
• 官网：https://www.docker.com/
• 官方文档：https://docs.docker.com/
• 仓库地址：https://hub.docker.com/

1.2 虚拟化技术和容器化技术对比

1.2.1 虚拟化技术的缺点

• 资源占用十分多
• 冗余步骤多
• 启动慢

1.2.2 容器化技术

1.2.3 比较Docker和虚拟化技术的不同
传统虚拟机， 虚拟出一条硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件
容器内的应用直接运行在宿主机的内部，容器是没有自己的内核的，也没有虚拟硬件，所以轻便
每个容器间是相互隔离的，每个容器内都有一个属于自己的文件系统，互不影响，应用更快速的交互和部署

1.3 DevOps（开发运维）

• 应用更快速的交付和部署

传统：一堆帮助文档，安装程序

Docker： 打包镜像发布测试，一键运行

• 更便捷的升级和扩缩容

项目打包成一个镜像，拓展服务器A、服务器B、.....

• 更简的系统运维

开发、测试环境是高度一致的

• 更高效的计算资源利用

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

二、安装

2.1 docker组成

客户端-服务器-仓库

docker服务去运行，守护进程通过镜像运行，生成很多的容器

• 镜像

docker镜像就像一个模板，可以通过模板来创建容器服务，例如tomcat镜像，通过镜像可以创建多个容器

• 容器

docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建

• 仓库

存放镜像的地方

docker hub

阿里云...都有容器服务（可以配置镜像加速）

2.2 安装

1）查看自己服务器的配置

uname -r

cat /etc/os-release

2）安装

• 卸载旧版本

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

• 下载需要的安装包

yum install -y yum-utils

• 设置镜像仓库

 sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

 可以使用阿里云、清华园等

yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

• 更新yum软件包索引

yum makecache fast

•  安装docker引擎

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

 docker-ce是社区版的 ee企业版

•  启动docker

systemctl start docker

• 验证

docker version

• 测试 

docker run hello-world

•  查看helloworld镜像

docker images

 

•  卸载docker

# 卸载
yum remove docker-ce docker-ce-cli containerd.io

# 删除资源 默认工作路径
rm -rf /var/lib/docker

 3）阿里云镜像加速

 选择contos，执行命令

sudo mkdir -p /etc/docker

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://j9yjyaas.mirror.aliyuncs.com"]
}
EOF

sudo systemctl daemon-reload

sudo systemctl restart docker

 2.3 底层原理

其实就是说  docker run helloworld以后  docker到底做了什么事情

 

2.3.1 工作原理

Docker Engine是一个客户端-服务器应用程序，具有以下主要组件:

一个服务器，它是一种长期运行的程序，称为守护进程(dockerd命令)
一个REST API，它指定程序可以用来与守护进程对话并指示它做什么的接口。

1）结构
Docker是一个Client-Server结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器。容器，是一个运行时环境就是集装箱。

 

2）为什么Docker比Vm快

• docker有着比虚拟机更少的抽象层。由于docker不需要Hypervisor实现硬件资源虚拟化，运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
• docker利用的是宿主机的内核，而不需要Guest OS。因此,当新建一个容器时,docker不需要和虚拟机一样重新加载一个操作系统内核。仍而避免引寻、加载操作系统内核返个比较费时费资源的过程,当新建一个虚拟机时,虚拟机软件需要加载GuestOS,返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一个docker容器只需要几秒钟
   

 三、docker常用命令

docker version    #版本信息
docker info       #系统信息 包括镜像和容器数量

 1）镜像命令

docker images     #查看镜像

--all , -a        # 列出所有镜像
--quiet , -q      # 只显示镜像的id
--filter, -f      # 过滤

搜索镜像

docker search mysql --filter=STARS=3000     #搜索mysql（也可以docker hub直接搜索）

 下载镜像

docker pull mysql       #默认最新版(分层下载-联合文件系统)
docker pull mysql:5.7   #指定版本（hub上存在）

 删除镜像

docker rmi -f $(docker images -aq)    #删除全部
docker rmi -f [id/tag/..]             #指定删除

 2）容器命令

docker pull centos

 容器里下载一个镜像

新建容器并启动

docker run -it centos /bin/bash      #启动并进入容器

--name="name"    #给容器起名字
-d               #后台方式运行
-it              #交互方式运行，进入容器查看内容
-P               #指定容器的端口 -p 8080:8080
    -P ip:主机端口:容器端口
    -P 主机端口:容器端口
    -P 容器端口
    容器端口
-p               #随机端口

docker ps              #正在运行的容器
docker ps -a           #正在运行的容器（包括历史容器）
docker ps -n=[参数]    #最近创建的容器
docker -q              #当前容器的编号

exit               #退出并关闭
ctrl+P+Q           #容器不关闭退出

docker rm -f 容器id                 # 删除指定容器
docker rm -f $(docker ps -aq)       # 删除所有容器
docker ps -a -q|xargs docker rm -f  # 删除所有的容器

docker start 容器id           # 启动容器
docker restart 容器id         # 重启容器
docker stop 容器id            # 停止当前正在运行的容器
docker kill 容器id            # 强制停止当前的容器

3）常用命令

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

docker logs -tf --tail number 容器id        #查看日志
-tf                                         #显示日志
--tail number                               #显示日志条数

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

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

docker exec -it 容器id /bin/bash            #进入当前正在运行的容器，进入容器后开启一个新的终端，可以在里面操作
docker attach 容器id                        #进入当前正在运行的容器，进入容器正在执行的终端，不会启动新的进程

docker cp 容器id:容器内路径 目的地主机路径      #从容器中拷贝文件到主机

三、docker部署软件

1、安装nginx

docker images   #查看镜像

docker run -d --name nginx01 -p 3344:80 nginx  # 后台方式启动启动镜像
# -d 后台运行
# -name 给容器命名
# -p 宿主机端口：容器内部端口

docker ps                                #查看当前运行镜像
curl localhost:3344                      #本地访问测试
docker exec -it nginx01 /bin/bash        # 进入容器

2、安装tomcat

docker run -it --rm tomcat:9.0        # 官方的使用
#docker run -it --rm 一般用来测试，用完就删
 
docker pull tomcat
docker run -d -p 3344:8080 --name tomcat01 tomcat
docker exec -it tomcat01 /bin/bash
 
# webapps下内容为空，阿里云默认是最小的镜像，所有不必要的都剔除了，保证最小可运行环境即可

3、安装es、kibana

服务器带不动（todo test）

# es 暴露的端口很多
# es 十分的耗内存
# es 的数据一般需要放置到安全目录！ 挂载
# --net somenetwork 网络配置
 
docker pull docker.elastic.co/elasticsearch/elasticsearch:8.6.0            #下载镜像
docker network create elastic                                              #创建网络

 docker run --name es01 \                                                  #运行
 -e ES_JAVA_OPTS="-Xms1g -Xmx1g" \
 -e "discovery.type=single-node"  \
 --net elastic  -p 9200:9200 -p 9300:9300 \
 -d docker.elastic.co/elasticsearch/elasticsearch:8.6.0

docker exec -it es01 /usr/share/elasticsearch/bin/elasticsearch-reset-password        #重置密码

docker cp es01:/usr/share/elasticsearch/config/certs/http_ca.crt .                    #复制 http_ca.crt 证书文件到本地

curl --cacert http_ca.crt -u elastic https://localhost:9200                           #测试访问

docker run -e ES_JAVA_OPTS="-Xms1g -Xmx1g" -e ENROLLMENT_TOKEN="<token>" --name es01 -p 9201:9200 --net elastic -it docker.elastic.co/elasticsearch/elasticsearch:8.6.0    #设置JVM参数

docker pull docker.elastic.co/kibana/kibana:8.6.0                                      #docker拉取kibana镜像

docker run --name kib01 --net elastic -p 5601:5601 docker.elastic.co/kibana/kibana:8.6.0        #启动kibana服务

docker network rm elastic        #卸载
docker rm es01
docker rm kib01




# 增加内存限制，修改配置文件 -e 环境配置修改
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

4、可视化

docker run -d -p 8088:9000 --restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer
 
# 测试
[root@iZ2zeg4ytp0whqtmxbsqiiZ home]# curl localhost:8088
<!DOCTYPE html
><html lang="en" ng-app="portainer">
 
# 外网访问 http://ip:8088
 

• portainer（先用这个）

• Rancher(CI/CD再用)

四、原理

4.1 镜像

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，包含运行某个软件所需要的所有的内容，包括代码、库、环境变量、配置文件等。

4.1.1 加载

UnionFS（联合文件系统）

UnionFS是一种分层、轻量级并且高性能的文件系统，支持对文件系统的修改，作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下。Union文件系统是Docker镜像的基础。

镜像可以通过分层进行继承，基于基础镜像，可以制作各种具体的应用镜像。

特性：

一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

4.2 docker镜像加载原理

dokcer的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。

bootfs（boot file system）主要包含bootloader和kernel，bootloader主要是引导加载kernel，linux刚启动时会加载bootfs文件系统，在docker镜像的最底层是bootfs。

这一层与典型的linux系统一致，包含boot加载器和内核，当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs。

rootfs（root file system），在bootfs之上，包含的就是典型linux系统中的/dev、/proc、/bin、/etc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如ubantu、centos等。

平时安装的虚拟机和centos都好几个G，为什么docker才200M？

对于一个精简的os，rootfs可以很小，只需要包含最基本的命令、工具、程序库就可以了，因为底层直接用host的kernel，自己只需要提供rootfs就可以了。

对于不同的linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以共用bootfs。

理解：

所有的dokcer镜像都起始于一个基础镜像层，当进行修改或增加新的内容时，就会在当前镜像层之上，创建新的镜像层。

举个例子 ，基于ubantu linux16.04创建一个新的镜像，这就是新镜像的第一层，如果在该镜像添加Python包，就会在基础镜像层上创建第二个镜像层，诸如此类。

在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合。

下图中，每个镜像层都包含3个文件，而镜像包含了来自两个镜像层的6个文件。

下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层的文件7是文件5的更新版本。

这种情况，上次镜像层中的文件覆盖了底层镜像层的文件，这样就使得文件的更新版本作为一个新镜像层添加到镜像中，

docker通过存储引擎（新版本采用快照机制）的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统。

linux上可用的存储引擎有AUFS、OVERLAY2、DEVICE MAPPER、BTRFS以及ZFS。每种存储引擎都基于linux中对应的文件系统或者块设备技术，并且每种存储引擎都有独有的性能特点。

4.3 特点

Docker镜像都是只读的，当容器启动时， 一个新的可写层被加载到镜像的顶部！

这一层就是我们通常说的容器层， 容器之下的都叫做镜像层

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

# 1. 启动一个默认的tomcat
# 2. 发现这个默认的tomcat是没有webapps应用， 镜像的原因，官方镜像默认webapps下面是没有内容的
# 3. 我自己拷贝进去了基本的文件
# 4. 将我们操作过的容器通过commit提价为一个镜镜像！我们以后就使用我们自己制作的镜像了

五，容器数据卷

5.1. 容器数据卷

5.1.1. docker的理解回顾

将应用和环境打包成一个镜像！

如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化

MySQL，容器删了，删库跑路！需求：MySQL数据可以存储在本地！

容器之间可以有一个数据共享技术！Docker容器中产生的数据，同步到本地！

这就是卷技术，目录的挂载，将我们容器内的目录挂载到linux目录上面！

总结：容器的持久化和同步操作！容器间数据也是可以共享的！

5.1.2 数据卷

• 命令

docker run -it -v 主机目录：容器目录
docker run -it -v /home/ceshi:/home centos /bin/bash

5.1.3 具名挂载和匿名挂载

# 匿名挂载
-P 随机指定端口
-v 容器内路径
docker run -d -P --name nginx01 -v /etc/nginx nginx    
 
# 查看所有volume的情况
# 这里发现，这种情况就是匿名挂载，我们在-v 后面只写了容器内的路径，没有写容器外的路径！
docker volume ls
DRIVER              VOLUME NAME
local               561b81a03506f31d45ada3f9fb7bd8d7c9b5e0f826c877221a17e45d4c80e096
 
# 具名挂载
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

docker volume ls
DRIVER              VOLUME NAME
local               561b81a03506f31d45ada3f9fb7bd8d7c9b5e0f826c877221a17e45d4c80e096
local               36083fb6ca083005094cbd49572a0bffeec6daadfbc5ce772909bb00be760882
local               juming-nginx
 
# 通过-v 卷名：容器内的路径
# 查看一下这个卷
docker volume inspect juming-nginx
[
  {
      "CreatedAt": "2023-01-12T18:15:21+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/xxxxx/_data

我们通过具名挂载可以方便的找到我们的一个卷，大多数情况下使用的是具名挂载

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

5.2 docker file

用来构建docker镜像的构建文件，通过这个脚本生成镜像。

镜像是一层一层的，命令就是一个一个的，一个命令相当于一个镜像。

# 创建一个dockerfile文件， 名字可以随机
# 文件的内容 指定（大写） 参数
vim dockerfile1

FROM centos
VOLUME ["volume01", "volume02"]
CMD echo "----end----"
CMD /bin/bash
 
# 这里的每一个命令都是镜像的一层！

构建镜像

docker build -f 文件路径 -t 镜像名:tag .
docker build -f dockerfile1 -t centos:1.0 .

 启动

docker run -it centos /bin/bash

 数据卷容器：

#启动三个容器
docker run -it --name docker01 centos：1.0
docker run -it --name docker02 --volumes-from docker01 centos：1.0
docker run -it --name docker03 --volumes-from docker01 centos：1.0

 docker02和docker03挂载到docker01上

数据共享，例如删除docker01，但是01和03依旧有数据，只要有一个容器还在用，数据就不会消失。

多个mysql共享数据：

docker run -d -p 3344:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
 
 docker run -d -p 3344:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7

结论

容器之间配置信息的传递， 数据卷容器的声明周期一直持续到没有容器使用为止。

但是一旦你持久化到了本地，这个时候，本地的数据是不会删除的。

 六、docker file

6.1 构建步骤

① 编写dockerfile文件

② docker build构建成镜像

③ docker run 运行

④ docker push 发布

在github上找到一个镜像，带有tag的文件，点击进入，出现的就是dockerfile的脚本。

很多官方的镜像都是基础包，通常自己去拓展。

 

dockerfile构建：

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

6.2 指令

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

DockerFile： 构建文件， 定义了一切的步骤，源代码

DockerImages： 通过DockerFile构建生成的镜像， 最终发布和运行的产品！

Docker容器：容器就是镜像运行起来提供服务器

 6.3 创建

# 1. 编写Dockerfile的文件
cat mydockerfile-centos 

FROM centos
MAINTAINER xxxxx<123456@qq.com>
ENV MYPATH /usr/local           # 相当于k-v形式
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 dockerfile文件路径 -t 镜像名:[tag] .
 
docker build -f mydockerfile-centos -t mycentos:0.1 .
 
Successfully built d2d9f0ea8cb2
Successfully tagged mycentos:0.1

6.3.1  CMD 和ENTRYPOINT区别

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

 CMD测试

# 1. 编写dockerfile文件
vim dockerfile-cmd-test 

FROM centos
CMD ["ls", "-a"]

# 2. 构建镜像
docker build -f dockerfile-cmd-test -t cmdtest .
 
# 3. run运行， 发现我们的ls -a 命令生效
docker run ebe6a52bb125
.
..
.dockerenv
bin
dev
etc
home
lib
lib64
 
# 想追加一个命令 -l 变成 ls -al
docker run ebe6a52bb125 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown.

docker run ebe6a52bb125 ls -l
 
# cmd的情况下 -l替换了CMD["ls", "-a"]命令， -l不是命令，所以报错了

 测试ENTRYPOINT

# 1. 编写dockerfile文件
vim dockerfile-entrypoint-test 

FROM centos
ENTRYPOINT ["ls", "-a"]
 
# 2. 构建文件
docker build -f dockerfile-entrypoint-test -t entrypoint-test .
 
# 3. run运行 发现我们的ls -a 命令同样生效
docker run entrypoint-test

.
..
.dockerenv
bin
dev
etc
home
lib
 
# 4. 我们的追加命令， 是直接拼接到ENTRYPOINT命令的后面的！
docker run entrypoint-test -l

total 56
drwxr-xr-x  1 root root 4096 Aug 13 07:52 .
drwxr-xr-x  1 root root 4096 Aug 13 07:52 ..
-rwxr-xr-x  1 root root    0 Aug 13 07:52 .dockerenv
lrwxrwxrwx  1 root root    7 May 11  2019 bin -> usr/bin
drwxr-xr-x  5 root root  340 Aug 13 07:52 dev
drwxr-xr-x  1 root root 4096 Aug 13 07:52 etc
drwxr-xr-x  2 root root 4096 May 11  2019 home
lrwxrwxrwx  1 root root    7 May 11  2019 lib -> usr/lib
lrwxrwxrwx  1 root root    9 May 11  2019 lib64 -> usr/lib64
drwx------  2 root root 4096 Aug  9 21:40 lost+found

七、tomcat实战

7.1 部署

① tomcat、jdk安装包上传到服务器

② dockerfile

cat Dockerfile 

FROM centos
MAINTAINER xxxx<123456@qq.com>
 
COPY readme.txt /usr/local/readme.txt
 
ADD jdk-8u73-linux-x64.tar.gz /usr/local/            #ADD命令自动解压
ADD apache-tomcat-9.0.37.tar.gz /usr/local/
 
RUN yum -y install vim
 
ENV MYPATH /usr/local
WORKDIR $MYPATH
 
ENV JAVA_HOME /usr/local/jdk1.8.0_73
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.37
ENV CATALINA_BASH /usr/local/apache-tomcat-9.0.37
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
 
EXPOSE 8080
 
CMD /usr/local/apache-tomcat-9.0.37/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.37/bin/logs/catalina.out

这里提供一个简易版的安装

# 使用基于 CentOS 的镜像
FROM centos:7
MAINTAINER shirley<1470762087@qq.com>


# 更新 CentOS 系统并安装 OpenJDK 和 curl 工具
RUN yum -y install vim
RUN yum update -y 
RUN yum install -y java-1.8.0-openjdk.x86_64 curl

ENV MYPATH /usr/local
WORKDIR $MYPATH

# 下载 Tomcat 压缩包并解压  如果报错，看下载地址是否正确
RUN curl -O https://downloads.apache.org/tomcat/tomcat-8/v8.5.85/bin/apache-tomcat-8.5.85.tar.gz
RUN tar xvzf apache-tomcat-8.5.85.tar.gz 
RUN mv apache-tomcat-8.5.85  /usr/local/tomcat 
RUN rm apache-tomcat-8.5.85.tar.gz

# 设置环境变量
ENV CATALINA_HOME /usr/local/tomcat
ENV PATH $CATALINA_HOME/bin:$PATH

# 开放 8080 端口
EXPOSE 8080

# 启动 Tomcat
CMD ["catalina.sh", "run"]

③ 构建镜像

docker build -t diytomcat .
#diytomcat自己定义的名字

④  启动

docker run -d -p 3344:8080 --name youtomcat -v /home/youtomcat/build/tomcat/test:/usr/local/apache-tomcat-9.0.37/webapps/test -v /home/youtomcat/build/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.37/logs diytomcat

不挂载简单的测试

docker run -it --rm -p 8080:8080 my-tomcat

⑤ 访问测试

⑥ 发布项目（由于做了卷挂载， 我们直接在本地编写项目就可以发布了）

7.2 发布到docker hub

① 注册账号、登录

docker login -u 码

② 提交

# push到我们的服务器上
docker push diytomcat

The push refers to repository [docker.io/library/diytomcat]
2eaca873a720: Preparing 
1b38cc4085a8: Preparing 
088ebb58d264: Preparing 
c06785a2723d: Preparing 
291f6e44771a: Preparing 
denied: requested access to the resource is denied  # 拒绝
 
# push镜像的问题？
The push refers to repository [docker.io/1314520007/diytomcat]
An image does not exist locally with the tag: 1314520007/diytomcat
 
# 解决，增加一个tag
docker tag diytomcat 1314520007/tomcat:1.0
docker push diytomcat 1314520007/tomcat:1.0

 7.3 发布到阿里云

① 登录阿里云

② 找到容器镜像服务

③ 创建命名空间

④ 创建容器镜像

⑥ 点击仓库名称，参考官方文档即可

总结

八、docker网络

8.1 docker0

# 问题： docker是如何处理容器网络访问的？

# docker run -d -P --name tomcat01 tomcat
# docker run -d -P --name tomcat02 tomcat
 
# 查看容器内部的网络地址 ip addr
# docker exec -it tomcat01 ip addr， 发现容器启动的时候得到一个eth0@if115 ip地址，docker分配的！
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
114: eth0@if115: <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
 
# 思考： linux 能不能ping通容器？
ping 172.17.0.2
 
# linux 可以 ping 通docker容器内部！

原理：

1、每启动一个docker容器， docker就会给docker容器分配一个ip， 只要安装了docker，就会有一个网卡 docker0桥接模式，使用的技术是veth-pair技术。

2、这个容器带来网卡，都是一对对的。veth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连着协议，一端彼此相连。正因这个特性，veth-pair充当一个桥梁， 连接各种虚拟网络设备。
OpenStac， Docker容器之间的链接，OVS的链接， 都是使用veth-pair技术

测试：

docker exec -it tomcat01 ip addr           #获取一个ip地址
docker exec -it tomcat02 ping 172.2.0.2    #测试是否能ping通

 容器与容器之间是可以相互ping通的

 

tomcat01和tomcat02是共用的一个路由器，docker0

所有容器不指定网络的情况下，都是docker0路由的，doucker会给容器分配一个默认的可用IP

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

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

 8.2 link

编写了一个微服务，database url =ip； 项目不重启，数据ip换掉了，希望可以处理这个问题，可以按名字来进行访问容器

# docker exec -it tomcat02 ping tomcat01
ping: tomcat01: Name or service not known
 
# 如何可以解决呢？
# 通过--link既可以解决网络连通问题
# docker run -d -P  --name tomcat03 --link tomcat02 tomcat
3a2bcaba804c5980d94d168457c436fbd139820be2ee77246888f1744e6bb473

# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                     NAMES
3a2bcaba804c        tomcat              "catalina.sh run"   4 seconds ago       Up 3 seconds        0.0.0.0:32772->8080/tcp   tomcat03
f22ed47ed1be        tomcat              "catalina.sh run"   57 minutes ago      Up 57 minutes       0.0.0.0:32771->8080/tcp   tomcat02
9d97f93401a0        tomcat              "catalina.sh run"   About an hour ago   Up About an hour    0.0.0.0:32770->8080/tcp   tomcat01

# 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.129 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=2 ttl=64 time=0.100 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=3 ttl=64 time=0.110 ms
64 bytes from tomcat02 (172.17.0.3): icmp_seq=4 ttl=64 time=0.107 ms
 
# 反向可以ping通吗？
# docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known

# docker exec -it 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 f22ed47ed1be
172.17.0.4  3a2bcaba804c

--link 就是在hosts配置中增加了一个172.17.0.3 tomcat02 f22ed47ed1be

现在Docker已经不建议使用--link了

自定义网络！不使用Docker0！

Docker0的问题：它不支持容器名链接访问。而link解决了这个问题。

8.3 自定义网络

查看所有docker网络

docker network ls

 

8.3.1 所有网络

bridge： 桥接模式，桥接 docker 默认，自己创建的也是用brdge模式

none： 不配置网络

host： 和宿主机共享网络

container：容器网络连通（用的少， 局限很大）

 8.3.2 创建一个

# 我们直接启动的命令默认有一个 --net bridge，而这个就是我们的docker0
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat
 
# docker0特点，默认，容器名不能访问， --link可以打通连接！
# 我们可以自定义一个网络！
# --driver bridge
# --subnet 192.168.0.0/16 可以支持255*255个网络 192.168.0.2 ~ 192.168.255.254
# --gateway 192.168.0.1

# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet
26a5afdf4805d7ee0a660b82244929a4226470d99a179355558dca35a2b983ec
# docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
30d601788862        bridge              bridge              local
226019b14d91        host                host                local
26a5afdf4805        mynet               bridge              local
7496c014f74b        none                null                local

#查看网络
docker network inspect mynet

自己创建的网络下，启动容器

# docker run -d -P --name tomcat-net-01 --net mynet tomcat
# docker run -d -P --name tomcat-net-02 --net mynet tomcat

# docker network inspect mynet
 
# 再次拼连接
# docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3) 56(84) bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 ttl=64 time=0.113 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.093 ms

# 现在不使用 --link也可以ping名字了！
# docker exec -it 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.068 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.096 ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=3 ttl=64 time=0.094 ms

好处：

redis - 不同的集群使用不同的网络，保证集群是安全和健康的

mysql - 不同的集群使用不同的网络，保证集群是安全和健康的

 8.4 网络连通

# docker network connect  mynet tomcat01
 
# 连通之后就是讲tomcat01 放到了mynet网路下
# 一个容器两个ip地址：
# 阿里云服务器，公网ip，私网ip

# 连通ok
# docker exec -it tomcat01 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.100 ms
64 bytes from tomcat-net-01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.085 ms

# 依旧无法连通，没有connect
# docker exec -it tomcat02 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known
 

8.4.1   集成redis

① 创建网卡

# 创建网卡
docker network create redis --subnet 172.38.0.0/16

 ② redis集成

可参考redis学习，集成脚本配置

# 通过脚本创建六个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

# 创建结点1
docker run -p 6371:6379 -p 16371:16379 --name redis-1 \
-v /mydata/redis/node-1/data:/data \
-v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
 
#创建结点2
docker run -p 6372:6379 -p 16372:16379 --name redis-2 \
-v /mydata/redis/node-2/data:/data \
-v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#创建结点3
docker run -p 6373:6379 -p 16373:16379 --name redis-3 \
-v /mydata/redis/node-3/data:/data \
-v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#创建结点4
docker run -p 6374:6379 -p 16374:16379 --name redis-4 \
-v /mydata/redis/node-4/data:/data \
-v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#创建结点5
docker run -p 6375:6379 -p 16375:16379 --name redis-5 \
-v /mydata/redis/node-5/data:/data \
-v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf

#创建结点6
docker run -p 6376:6379 -p 16376:16379 --name redis-6 \
-v /mydata/redis/node-6/data:/data \
-v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf \
-d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
 
# 创建集群
# docker exec -it redis-1 /bin/sh
/data # ls
appendonly.aof  nodes.conf
/data # 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
>>> Performing hash slots allocation on 6 nodes...
Master[0] -> Slots 0 - 5460
Master[1] -> Slots 5461 - 10922
Master[2] -> Slots 10923 - 16383
Adding replica 172.38.0.15:6379 to 172.38.0.11:6379
Adding replica 172.38.0.16:6379 to 172.38.0.12:6379
Adding replica 172.38.0.14:6379 to 172.38.0.13:6379
M: 541b7d237b641ac2ffc94d17c6ab96b18b26a638 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
M: a89c1f1245b264e4a402a3cf99766bcb6138dbca 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
M: 259e804d6df74e67a72e4206d7db691a300c775e 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
S: 9b19170eea3ea1b92c58ad18c0b5522633a9e271 172.38.0.14:6379
   replicates 259e804d6df74e67a72e4206d7db691a300c775e
S: 061a9d38f22910aaf0ba1dbd21bf1d8f57bcb7d5 172.38.0.15:6379
   replicates 541b7d237b641ac2ffc94d17c6ab96b18b26a638
S: 7a16b9bbb0615ec95fc978fa62fc054df60536f0 172.38.0.16:6379
   replicates a89c1f1245b264e4a402a3cf99766bcb6138dbca
Can I set the above configuration? (type 'yes' to accept): yes
>>> Nodes configuration updated
>>> Assign a different config epoch to each node
>>> Sending CLUSTER MEET messages to join the cluster
Waiting for the cluster to join
...
>>> Performing Cluster Check (using node 172.38.0.11:6379)
M: 541b7d237b641ac2ffc94d17c6ab96b18b26a638 172.38.0.11:6379
   slots:[0-5460] (5461 slots) master
   1 additional replica(s)
M: a89c1f1245b264e4a402a3cf99766bcb6138dbca 172.38.0.12:6379
   slots:[5461-10922] (5462 slots) master
   1 additional replica(s)
S: 7a16b9bbb0615ec95fc978fa62fc054df60536f0 172.38.0.16:6379
   slots: (0 slots) slave
   replicates a89c1f1245b264e4a402a3cf99766bcb6138dbca
S: 061a9d38f22910aaf0ba1dbd21bf1d8f57bcb7d5 172.38.0.15:6379
   slots: (0 slots) slave
   replicates 541b7d237b641ac2ffc94d17c6ab96b18b26a638
M: 259e804d6df74e67a72e4206d7db691a300c775e 172.38.0.13:6379
   slots:[10923-16383] (5461 slots) master
   1 additional replica(s)
S: 9b19170eea3ea1b92c58ad18c0b5522633a9e271 172.38.0.14:6379
   slots: (0 slots) slave
   replicates 259e804d6df74e67a72e4206d7db691a300c775e
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
 
 

 九、docker compose

9.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

② 授权

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

官网实例：

https://docs.docker.com/compose/gettingstarted/

9.2 实例

① 编写项目微服务

② Dockerfile构建镜像

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

③ 服务器

docker-compose down         # 关闭容器
docker-compose up --build   # 重新构建

④ 登录

xxxxxxx:8080/hello

十、socker swarm

10.1 服务器

购买4台服务器，安装docker

① 初始化

docker swarm init --help
 
ip addr # 获取自己的ip（用内网的不要流量）
 
# docker swarm init --advertise-addr 172.16.250.97
Swarm initialized: current node (otdyxbk2ffbogdqq1kigysj1d) is now a manager.
 
To add a worker to this swarm, run the following command:
    docker swarm join --token SWMTKN-1-3vovnwb5pkkno2i3u2a42yrxc1dk51zxvto5hrm4asgn37syfn-0xkrprkuyyhrx7cidg381pdir 172.16.250.97:2377
To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.
 

② 加入一个节点

# 获取令牌
docker swarm join-token manager
docker swarm join-token worker

# docker swarm join --token SWMTKN-1-3vovnwb5pkkno2i3u2a42yrxc1dk51zxvto5hrm4asgn37syfn-0xkrprkuyyhrx7cidg381pdir 172.16.250.97:2377
This node joined a swarm as a worker.
 

4台同样的操作