目录
对docker的理解
Docker是基于Go语言实现的云开源项目。 Docker的主要目标是Build，Ship and Run Any App,Anywhere，也就是通过对应用组件的封装、 分发、部署、运行等生命周期的管理，使用户的APP（可以是一个WEB应用或数据库应用等等）及其运 行环境能够做到一次封装，到处运行。
Linux 容器技术的出现就解决了这样一个问题，而 Docker 就是在它的基础上发展过来的。将应用运 行在 Docker 容器上面，而 Docker 容器在任何操作系统上都是一致的，这就实现了跨平台、跨服务 器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作。
能做什么
传统虚拟机
虚拟机（virtual machine）就是带环境安装的一种解决方案。
它可以在一种操作系统里面运行另一种操作系统，比如在Windows 系统里面运行Linux 系统。应用 程序对此毫无感知，因为虚拟机看上去跟真实系统一模一样，而对于底层系统来说，虚拟机就是一个普 通文件，不需要了就删掉，对其他部分毫无影响。这类虚拟机完美的运行了另一套系统，能够使应用程 序，操作系统和硬件三者之间的逻辑不变。
传统虚拟机的缺点：
1. 资源占用多
2. 冗余步骤多
3. 启动慢
容器虚拟化技术
由于前面虚拟机存在这些缺点，Linux 发展出了另一种虚拟化技术：Linux 容器（Linux Containers，缩写为 LXC）。
Linux 容器不是模拟一个完整的操作系统，而是对进程进行隔离。有了容器，就可以将软件运行所 需的所有资源打包到一个隔离的容器中。容器与虚拟机不同，不需要捆绑一整套操作系统，只需要软件 工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。
Docker 和传统虚拟化方式的不同之处
1. 传统虚拟机技术是虚拟出一套硬件后，在其上运行一个完整操作系统，在该系统上再运行所需应用进程；
2. 而容器内的应用进程直接运行于宿主的内核，容器内没有自己的内核，而且也没有进行硬件虚拟。 因此容器要比传统虚拟机更为轻便。
3. 每个容器之间互相隔离，每个容器有自己的文件系统 ，容器之间进程不会相互影响，能区分计算资源。
DOCKER的优点：
1. 一次构建，随处运行
2. 更快速的应用交付和部署
3. 更便捷的升级和扩缩容
4. 更简单的系统运维
5. 更高效的计算资源利用
Docker的安装
官网: http://www.docker.com
仓库: Docker
前置环境
Docker支持以下的CentOS版本：
CentOS 7 (64-bit) 8
CentOS 6.5 (64-bit) 或更高的版本
前提条件 目前，CentOS 仅发行版本中的内核支持 Docker。
Docker 运行在 CentOS 7 上，要求系统为64位、系统内核版本为 3.10 以上。
Docker 运行在 CentOS-6.5 或更高的版本的 CentOS 上，要求系统为64位、系统内核版本为 2.6.32-431 或者更高版本。
查看自己的内核 uname命令用于打印当前系统相关信息（内核版本号、硬件架构、主机名称和操作系统类型等）。
Vagrant虚拟机环境
这里通过VirtualBox结合Vagrant来安装虚拟机
VirtualBox官网：Oracle VM VirtualBox
Vagrant官网：https://www.vagrantup.com/
Vagrant镜像仓库：Discover Vagrant Boxes – Vagrant Cloud
安装VirtualBox和Vagrant，傻瓜式安装。安装完成后需要重启计算机。 在cmd命令窗口输入 vagrant 命令弹出如下内容表示 vagrant 安装成功
VirtualBox下载：
Vagrant下载：
VirtualBox：
无脑安装，点击下一步即可，PS: 安装位置需要自选
Vagrant：
无脑安装，点击下一步即可，PS: 安装位置需要自选
黑窗口输入vagrant，显示如下表示安装成功：
使用Vgrant安装虚拟机
1. 输入命令(输入完毕后会在目录下生成Vagrantfile文件)：
vagrant init centos/7
2. 输入命令（执行完毕后自动在当前目录下载安装镜像文件）：
vagrant up
3. 此时如果出现报错
4. 需要修改vagrant文件，增加：config.vm.box_download_insecure=true
5. 配置默认虚拟的位置在没有中文的路径下
6. virtualBox出现以下为安装成功
7. 通过命令：vagrant ssh 命令连接虚拟机，此时使用的是vagrant账号
8. 如果需要切换账号，使用命令：sudo -i 切换成root用户
虚拟机网络的配置
1. 查看本机ip的网段。
2. 打开vagrantfile文件，修改里面的IP地址，和电脑给虚拟机分配的网段一致。
3. 在Oracle VM VirtualBox中鼠标右键，点击正常关闭，关闭虚拟机。
4. 使用xhsell连接虚拟机，通过密钥的方式连接。
1. 进入官网：Install Docker Engine on CentOS | Docker Documentation
2. 粘贴命令到xshell：
sudo yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
3. 出现以下提示，证明之前没安装过docker
4. 执行以下命令，安装依赖
sudo yum install -y yum-utils5. 配置镜像地址：
sudo yum-config-manager \
--add-repo \
https://download.docker.com/linux/centos/docker-ce.repo
6. 执行命令，安装docker
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin7. 启动docker
sudo systemctl start docker8. 查看docker版本
docker version
9. 设置开机自启动docker
systemctl enable docker
Docker的架构设计
镜像(image)
Docker 镜像（Image）就是一个只读的模板。镜像可以用来创建 Docker 容器，一个镜像可以创建 很多容器。
容器(container)
Docker 利用容器（Container）独立运行的一个或一组应用。容器是用镜像创建的运行实例。它可 以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。可以把容器看做是一个简 易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程 序。容器的定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。
仓库(repository)
仓库（Repository）是集中存放镜像文件的场所。 仓库(Repository)和仓库注册服务器（Registry）是有区别的。仓库注册服务器上往往存放着多个仓 库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag）。 仓库分为公开仓库（Public）和私有仓库（Private）两种形式。 最大的公开仓库是 Docker Hub(https://hub.docker.com/)，存放了数量庞大的镜像供用户下载。 国内的公开仓库包括阿里云 、网易云 等
仓库：访问地址：Docker
总结
image 文件生成的容器实例，本身也是一个文件，称为镜像文件。 一个容器运行一种服务，当我们需要的时候，就可以通过docker客户端创建一个对应的运行实例， 也就是我们的容器 至于仓储，就是放了一堆镜像的地方，我们可以把镜像发布到仓储中，需要的时候从仓储中拉下来 就可以了。
阿里云镜像服务配置
默认访问的仓库是在国外所以访问速度是没法保证的。为了更好的体验，我们可以配置阿里云的镜像加速
开放云原生应用-云原生（Cloud Native）-云原生介绍 – 阿里云
https://cr.console.aliyun.com/cn-zhangjiakou/instances/mirrors
依次执行命令：
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://cdy3fxsh.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
Docker的常用命令
镜像命令
镜像命令 说明
docker images 列出本地主机上的镜像
docker search 镜像名称 从 docker hub 上搜索镜像
docker pull 镜像名称 从docker hub 上下载镜像
docker rmi 镜像名称 删除本地镜像
docker images
docker images -a
docker images -q
docker images --digests
docker images --no-trunc
docker search
docker hub是Docker的在线仓库，我们可以通过docker search 在上面搜索我们需要的镜像
docker search --no-trunc
docker search -limit 5 tomcat
docker search -f STARS=5 tomcat
Docker pull
从Docker hub 上下载镜像文件，执行命令：
docker pull tomcat
docker pull redis
Docker rmi
#删除一个 rmi后面跟上IMAGEID
docker rmi -f 7614ae9453d1
#删除多个 rmi后面跟上 软件名称1：tag1 软件名称2：tag2
docker rmi -f redis:latest tomcat:latest
#删除所有的镜像ID docker images -qa 会获取所有的镜像ID
docker rmi -f $(docker images -qa)
容器常用命令
下载centos7
执行命令：
docker pull centos:centos7创建并启动容器
docker run [OPTIONS] IMAGE [COMMAND]
交互式的容器
docker run -it centos:centos7 /bin/bash1. 创建容器：
docker run -it centos:centos7 /bin/bash2. 切换窗口，重新链接虚拟机，执行命令，查看正在运行的docker容器
docker ps
3. 在运行的docker容器中创建文件
4. 查看是否能看到创建的文件
5. 证明是两套环境
6. 通过命令查看所有的容器以及状态
docker ps -a 
列举运行的容器
我们要查看当前正在运行的容器有哪些，可以通过ps 命令来查看
docker ps [OPTIONS]
#显示所有的容器 包含正在运行和停的
docker ps -a
#显示最近创建的容器
docker ps -l
#显示最近创建的几个容器 数字是几就是显示几个
docker ps -n 2
#只显示容器编号
docker ps -q
#显示容器的所有的信息 不截断输出
docker ps --no-turnc
退出容器命令
#容器停止且退出
exit
#容器不停止退出
ctrl+p+q
启动容器
docker start 容器ID或者容器名称
#显示出当前所有的容器信息
docker ps -a
#根据显示的容器ID启动容器
docker start e225ba310ead
重启容器
docker restart 容器id或者名称
#显示出当前所有的容器信息
docker ps -a
#重启容器
docker restart e225ba310ead
停止容器
docker stop 容器ID或者名称
还可以通过强制停止方式处理
docker kill 容器ID或者名称
#显示出当前所有的容器信息
docker ps -a
#停止容器
docker stop e225ba310ead
#查看容器是否运行
docker ps
#强制停止容器
docker kill e225ba310ead
#查看容器是否运行
docker ps
删除容器
有时候容器使用完成就没有作用了，我们想要删除掉容器，这时可以通过rm命令 ：
docker rm 容器ID
docker rm -f $(docker ps -qa)
docker ps -a -q | xargs docker rm
#显示出当前所有的容器信息
docker ps -a
#按照容器id删除容器
docker rm e225ba310ead
#显示出当前所有的容器信息
docker ps -a
#删除所有的容器
docker rm $(docker ps -qa)
#显示出当前所有的容器信息
docker ps -a
#下载helloworld镜像
docker run hello-world
#删除所有的容器
docker ps -aq | xargs docker rm
其他命令
docker run -d 容器名称
我们通过 docker ps -a 可以看到刚刚启动的容器已经退出了
为了让守护式容器能够一直执行，我们可以在启动容器后在后台运行一个循环的脚本
docker run -d centos /bin/bash -c ‘while true;do echo hello bobo;sleep 2;done’
查看我们运行的日志
docker logs -t -f –tail 3 容器ID
docker logs -t -f --tail 3 04f46687e241
查看容器中运行的进程
docker top 容器ID
查看容器细节
我们想要查看容器的细节可以通过inspect命令
docker inspect 容器ID
docker inspect 04f46687e241
进入运行的容器
copy 是复制 add是添加并解压
在容器内部执行命令，查看容器内部的文件：
docker exec -it 04f46687e241 ls
进入容器，打印出容器中执行的日志
docker attach 04f46687e241进入容器
docker exec -it b73b /bin/bash文件复制
我们有时需要从容器中拷贝内容到宿主机中
docker cp 容器ID:容器内路径 目的地路径
docker cp d798b92d6cae:/root/hello.txt /root
Docker镜像文件
镜像是什么
首先我们来看看镜像到底是什么？虽然前面有介绍过 镜像 和 容器 ,但也不是特别的深入。
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它 包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。
UnionFS
UnionFS（联合文件系统）: Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系 统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文 件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像 的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜 像。
特性 ：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件 系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录
镜像加载原理
Docker镜像加载原理： Docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
Bootfs(boot file system)主要包含Bootloader和Kernel, Bootloader主要是引导加载Kernel, Linux 刚启动时会加载Bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系 统是一样的，包含Boot加载器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用 权已由bootfs转交给内核，此时系统也会卸载bootfs。
Rootfs (root file system) ，在Bootfs之上。包含的就是典型 Linux 系统中的 /dev, /proc, /bin, /etc 等标准目录和文件。Rootfs就是各种不同的操作系统发行版，比如Ubuntu，Centos等等。
分层的镜像
其实我们前面在 pull 文件的时候比如 Tomcat，在pull界面我们就可以看到下载的文件是一层层的。
分层结构的特点
其实我们也会考虑docker为什么会才用这种分层的结果，它有什么好处呢？最大的一个好处就是共 享资源 比如：有多个镜像都从相同的 base 镜像构建而来，那么宿主机只需在磁盘上保存一份base镜像， 同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。
镜像的特点
大家需要注意，Docker镜像都是只读的，当容器启动时，一个新的可写层被加载到镜像的顶部，这一 层通常被称为容器层,容器层之下的都叫镜像层。
镜像的操作
下载tomcat镜像
docker pull tomcat
创建容器并启动
将容器中的8080端口映射到本机的8888端口启动。
docker run -it -p 8888:8080 tomcat 
能访问到服务，但是报错404代表服务启动无问题。
修改容器
容器中没有访问的资源，自己创建一个。
进入tomcat目录下：
docker exec -it 容器ID /bin/bash创建文件：
访问:
创建镜像
我们现在的容器和下载的有区别了，我们可以在这个基础上来创建新的镜像
docker commit -a='bobo' -m='add index.html' 容器ID bobo/tomcat:1.666
启动新的镜像
现在我们可以通过我们自己新创建的镜像文件来创建并启动容器了
docker run -it -p 8888:8080 bobo/tomcat:1.6666
或者
docker run -it -p 8888:8080 1b5ba6ab2677
数据卷
概念
前面我们介绍了镜像和容器，通过镜像我们可以启动多个容器，但是我们发现当我们的容器停止获取 删除后，我们在容器中的应用的一些数据也丢失了，这时为了解决容器的数据持久化，我们需要通过容 器数据卷来解决这个问题
数据卷是什么
Docker容器产生的数据，如果不通过docker commit生成新的镜像，使得数据做为镜像的一部分保 存下来，那么当容器删除后，数据自然也就没有了。为了能保存数据在docker中我们使用卷。简单来 说，容器卷就相当于Redis中持久化方式的RDB和AOF。
解决了什么问题
卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，因 此能够绕过Union File System提供一些用于持续存储或共享数据的特性： 卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会在容器删除时删除其挂载的数据卷
特点：
1. 数据卷可在容器之间共享或重用数据
2. 卷中的更改可以直接生效
3. 数据卷中的更改不会包含在镜像的更新中
4. 数据卷的生命周期一直持续到没有容器使用它为止
持久化，容器间继承和共享数据
数据卷使用
运行一个centos容器，将本地的路径挂载到宿主机中的路径。
docker run -it -v /宿主机绝对路径:/容器内目录 镜像名
docker run -it -v /root/dockerfile1:/root/docker1 centos
查看容器细节
docker inspect 容器ID
权限控制
只在宿主机中可写，在容器中只读
docker run -it -v /root/dockefA:/root/dockerfB:ro centos在容器中只读：
在宿主机中可读可写：
通过dockerfile添加数据卷
宿主机跟目录下创建一个mydocker，并在该目录下创建一个文件，内容如下：
# volume test
FROM centos
VOLUME ["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "finished,--------success1"
CMD /bin/bash
通过创建的文件构建docker镜像
docker build -f docke1 -t lc/centos .
宿主机中挂载的路径可以通过命令查看：
docker inspect 容器ID
数据卷容器
实现宿主机、容器之间的数据共享
命名的容器挂载数据卷，其他容器通过挂载这个容器实现数据共享，挂载数据的容器，称之为数据卷容器。
1. 启动父容器
docker run -it --name dc01 lc/centos2. 启动子容器1，挂载父容器
docker run -it --name dc02 --volumes-from dc01 lc/centos- 启动子容器2，挂载父容器
docker run -it --name dc03 --volumes-from dc01 lc/centos- 查看启动效果
在父容器的dataVolumeContainer1中创建文件a.txt
- 在子容器的dataVolumeContainer1中，可以看到a.txt文件
无论是在容器1、容器2、父容器、宿主机中修改文件，各处都可见修改后的内容。
DockerFile
DockerFile是用来构建Docker镜像的 构建文件 ，是由一系列 命令 和 参数 构成的 脚本
构建过程
Dockerfile中的指令需要满足如下的规则
执行流程
docker执行一个Dockerfile脚本的流程大致如下：
1. docker从基础镜像运行一个容器
2. 执行一条指令并对容器作出修改
3. 执行类似docker commit的操作提交一个新的镜像层
4. docker再基于刚提交的镜像运行一个新的容器
5. 执行dockerfile中的下一条指令直到所有指令都执行完成
从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，
Dockerfile是软件的原材料
Docker镜像是软件的交付品
Docker容器则可以认为是软件的运行态。
Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力 充当Docker体系的基石。
1. Dockerfile，需要定义一个Dockerfile，Dockerfile定义了进程需要的一切东西。Dockerfile涉及的 内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行 版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道，这时需要考虑如何设计 namespace的权限控制)等等;
2. Docker镜像，在用Dockerfile定义一个文件之后，docker build时会产生一个Docker镜像，当运行 Docker镜像时，会真正开始提供服务;
3. Docker容器，容器是直接提供服务的。
自定义镜像
编写一个dockerfile文件
#以哪个镜像文件为基础，从哪继承而来
FROM centos:centos7
#作者的邮箱
MAINTAINER luocong<luocong526@163.com>
#设置环境变量
ENV MYPATH /usr/local
#终端链接后默认进入的目录
WORKDIR $MYPATH
#添加指令支持
RUN yum -y install vim
#对外暴露端口为80
EXPOSE 80
#输出执行信息
CMD echo $MYPATH
CMD echo "success --->"
CMD /bin/bash
构建
然后将脚本构建成对应的镜像文件。
docker build -f dockerfile名称 -t 新建的镜像名:TAG .
docker build -f docker1 -t mycentos .
运行
docker run -it 镜像名称
docker run -it mycentos
镜像历史
docker history 镜像名称
docker history mycentos
自定义Tomcat
创建个tomcat目录
添加一个文件
在当前目录下创建一个 hello.txt 文件，作用是 COPY 到容器中
拷贝相关软件
准备对应的 jdk 和 tomcat 的压缩文件。
创建Dockerfile文件
创建对应的Dockerfile文件，如下：
FROM centos
MAINTAINER luocong<luocong526@163.com>
#把宿主机当前上下文的hello.txt拷贝到容器/usr/local/路径下
COPY hello.txt /usr/local/helloincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u351-linux-x64_(1).tar.gz /usr/local/
ADD apache-tomcat-9.0.70.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_351
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.70
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.70
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.70/bin/startup.sh" ]
# CMD ["/usr/local/apache-tomcat-9.0.70/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.70/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.70/bin/logs/catalina.out
构建
docker build -f docker3 -t mytomcat .
运行
docker run -it -p 9080:8080 --name mytomcat -v /root/dockerfile/tomcat/test:/usr/local/apache-tomcat-9.0.70/webapps/test -v /root/dockerfile/tomcat/tomcatlogs/:/usr/local/apache-tomcat-9.0.70/logs -- privileged=true mytomcat访问测试
在宿主机挂载的对应的目录中创建web.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
id="WebApp_ID" version="2.5">
<display-name>test</display-name>
</web-app>
创建jsp文件
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
-----------welcome------------
<%="i am in docker tomcat self "%>
<br>
<br>
<% System.out.println("=============docker tomcat self");%>
</body>
</html>
MySql安装
拉取mysql文件
docker pull mysql:5.6
运行容器：
docker run -p 12345:3306 --name mysql -v /root/mysql/conf:/etc/mysql/conf.d -v /root/mysql/logs:/logs -v /root/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6
通过工具链接mysql数据库
Redis安装
拉取文件：
docker pull redis:4.0
启动redis：
docker run -p 6379:6379 -v /root/myredis/data:/data -v /root/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis:4.0 redis-server /usr/local/etc/redis/redis.conf --appendonly yes进入运行中的redis容器：
docker exec -it f2b70fe249d0 redis-cliDocker网络
Docker是基于Linux Kernel的namespace，CGroups,UnionFileSystem等技术封装成的一种自定义 容器格式，从而提供了一套虚拟运行环境。
namespace: 用来做隔离的，比如 pid[进程]、net【网络】、mnt【挂载点】
CGroups：Controller Groups 用来做资源限制，比如内存和CPU等 Union
File Systems：用来做Image和Container分层
自定义netWork
创建一个network，类型为 Bridge
docker network create tomcat-net
或者
docker network create tomcat-net --subnet=172.18.0.0/24 tomcat-net
查看已有的NetWork:
docker network ls
查看tomcat-net详情信息：
docker network inspect tomcat-net删除network：
docker network rm tomcat-net创建tomcat容器，并指定使用tomcat-net
docker run -d --name custom-net-tomcat --network tomcat-net tomcat-ip:1.0
查看custom-net-tomcat的网络信息:截取了关键信息
查看网卡接口信息
brctl show 
此时在custom-net-tomcat容器中ping一些tomcat01发现是ping不通的
docker exec -it custom-net-tomcat ping 172.17.0.2此时如果tomcat01容器能够连接上tomcat-net上应该就可以了
docker network connect tomcat-net tomcat01
docker实战
搭建MySql数据库集群
1. 拉取mysql镜像
docker pull percona/percona-xtradb-cluster:5.7.21
2. 复制pxc镜像【重命名】
docker tag percona/percona-xtradb-cluster:5.7.21 mysqlcluster
3. 删除原来的镜像
docker rmi percona/percona-xtradb-cluster:5.7.21
4. 创建单独的网段，给MySQL数据库集群使用
docker network create --subnet=172.30.0.0/24 mysqlcluster
5. 创建和删除volume 不执行
docker volume create --name v1 # 创建 volume
docker volume rm v1 # 删除volume
docker volume inspect v1 # 查看详情
6.搭建pxc集群，准备三个数据卷
docker volume create --name mysql1
docker volume create --name mysql2
docker volume create --name mysql3
7. 运行3个PXC容器
[CLUSTER_NAME PXC集群名字]
[XTRABACKUP_PASSWORD数据库同步需要用到的密码]
8. 创建第一个节点
docker run -d -p 3301:3306 -v mysql1:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=MSQLCLUSTER -e EXTRABACKUP_PASSWORD=123456 --privileged --name=nodeI --net=mysqlcluster --ip=172.30.0.2 mysqlcluster9. 创建第二个和第三个节点: 注意 -e CLUSTER_JOIN=node1
docker run -d -p 3302:3306 -v mysql2:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=MSQLCLUSTER -e EXTRABACKUP_PASSWORD=123456 -e CLUSTER_JOIN=nodeI --privileged --name=nodeII --net=mysqlcluster --ip=172.30.0.3 mysqlclusterdocker run -d -p 3303:3306 -v mysql3:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -e CLUSTER_NAME=MSQLCLUSTER -e EXTRABACKUP_PASSWORD=123456 -e CLUSTER_JOIN=nodeI --privileged --name=nodeIII --net=mysqlcluster --ip=172.30.0.4 mysqlcluster
10. 测试连接 成功即可
HaProxy负载均衡
拉取镜像：
docker pull haproxy 
进入tmp目录：
创建文件夹haproxy
进入文件夹，创建文件haproxy.cfg
cd /tmp
mkdir haproxy
cd haproxy
touch haproxy.cfg
vi haproxy.cfg
加入以下内容：
global
#工作目录，这边要和创建容器指定的目录对应
# chroot /usr/local/etc/haproxy
#日志文件
log 127.0.0.1 local5 info
#守护进程运行
daemon
defaults
log global
mode http
#日志格式
option httplog
#日志中不记录负载均衡的心跳检测记录
option dontlognull
#连接超时（毫秒）
timeout connect 5000
#客户端超时（毫秒）
timeout client 50000
#服务器超时（毫秒）
timeout server 50000
#监控界面
listen admin_stats
#监控界面的访问的IP和端口
bind 0.0.0.0:8888
#访问协议
mode http
#URI相对地址
stats uri /dbs_monitor
#统计报告格式
stats realm Global\ statistics
#登陆帐户信息
stats auth admin:admin
#数据库负载均衡
listen proxy-mysql
#访问的IP和端口，haproxy开发的端口为3306
#假如有人访问haproxy的3306端口，则将请求转发给下面的数据库实例
bind 0.0.0.0:3306
#网络协议
mode tcp
#负载均衡算法（轮询算法）
#轮询算法：roundrobin
#权重算法：static-rr
#最少连接算法：leastconn
#请求源IP算法：source
balance roundrobin
#日志格式
option tcplog
#在MySQL中创建一个没有权限的haproxy用户，密码为空。
#Haproxy使用这个账户对MySQL数据库心跳检测
option mysql-check user haproxy
server MySQL_1 172.30.0.4:3306 check weight 1 maxconn 2000
server MySQL_2 172.30.0.4:3306 check weight 1 maxconn 2000
server MySQL_3 172.30.0.4:3306 check weight 1 maxconn 2000
#使用keepalive检测死链
option tcpka
创建haproxy容器
docker run -d -p 8888:8888 -p 3306:3306 -v /tmp/haproxy:/usr/local/etc/haproxy --name haproxy01 --privileged --net=mysqlcluster haproxy在MySQL数据库上创建用户，用于心跳检测
CREATE USER 'haproxy'@'%' IDENTIFIED BY '';
浏览器访问：
http://192.168.56.10:8888/dbs_monitor
SpringBoot项目部署
项目架构:
为springboot项目创建网络：
docker network create --subnet=172.24.0.0/24 sbm-net
创建mysql数据库表：
create database test；
use test;
CREATE TABLE
t_user
(
uid INT NOT NULL AUTO_INCREMENT,
uname VARCHAR(20),
PRIMARY KEY (uid)
)
ENGINE=InnoDB DEFAULT CHARSET=utf8 DEFAULT COLLATE=utf8_general_ci;
创建ssm项目：
参考Vue+Axios+SSM框架实现增删改查与文件上传_只为code醉的博客-CSDN博客
将创建的项目打包成jar包，上传至服务器
cd /tmp
mkdir springboot
cd springboot/
yum install -y lrzsz
输入sz 上传jar包
创建DockerFile文件
vi Dockerfile
加入以下内容：
FROM openjdk:8
MAINTAINER bobo
LABEL name="springboot-mybatis" version="1.0" author="bobo"
COPY ssm-0.0.1-SNAPSHOT.jar ssm-SNAPSHOT.jar
CMD ["java","-jar","ssm-SNAPSHOT.jar"]
构建dockerfile文件
docker build -t sbm-image .
启动jar包的镜像：
docker run -d --name sb01 -p 8081:8080 --net=sbm-net --ip=172.24.0.11 sbm-image浏览器访问：
http://192.168.56.20:8081/getList
下载nginx镜像
docker pull nginx进入tmp目录下：
cd /tmp
mkdir nginx
vi nginx.conf
加入以下内容：
user nginx;
worker_processes 1;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
server {
listen 80;
location / {
proxy_pass http://balance;
}
}
upstream balance{
server 172.24.0.11:8080;
server 172.24.0.12:8080;
server 172.24.0.13:8080;
}
include /etc/nginx/conf.d/*.conf;
}
启动nginx：
docker run -d --name my-nginx -p 80:80 -v /tmp/nginx/nginx.conf:/etc/nginx/nginx.conf --network=sbm-net --ip 172.24.0.20 nginx浏览器访问：
DockerCompose
介绍
Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文 件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服 务。
一键启动所有的服务
DockerCompose的使用步骤
创建对应的DockerFile文件
创建yml文件，在yml文件中编排我们的服务
通过 docker-compose up 命令 一键运行我们的容器
Compose安装
官网地址：Overview | Docker Documentation
执行命令：
curl -L "https://github.com/docker/compose/releases/download/1.29.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose修改文件夹权限：
chmod +x /usr/local/bin/docker-compose建立软连接：
ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose校验是否安装成功：
docker-compose --version
Compose一键部署实战
部署博客项目
创建文件夹
mkdir my-wordpress
cd my-wordpress/
vi docker-compose.yml
加入以下内容：
services:
db:
# We use a mariadb image which supports both amd64 & arm64 architecture
#image: mariadb:10.6.4-focal
# If you really want to use MySQL, uncomment the following line
image: mysql:8.0.27
command: '--default-authentication-plugin=mysql_native_password'
volumes:
- db_data:/var/lib/mysql
restart: always
environment:
- MYSQL_ROOT_PASSWORD=somewordpress
- MYSQL_DATABASE=wordpress
- MYSQL_USER=wordpress
- MYSQL_PASSWORD=wordpress
expose:
- 3306
- 33060
wordpress:
image: wordpress:latest
volumes:
- wp_data:/var/www/html
ports:
- 80:80
restart: always
environment:
- WORDPRESS_DB_HOST=db
- WORDPRESS_DB_USER=wordpress
- WORDPRESS_DB_PASSWORD=wordpress
- WORDPRESS_DB_NAME=wordpress
volumes:
db_data:
wp_data:
通过up命令启动
docker-compose up -d浏览器访问：
http://192.168.56.30/wp-admin/install.php
Compose部署Springboot项目
1. 创建springboot项目，依赖选择web、redis
2. application.properties文件中增加以下内容：
server.port=8080
spring.redis.host=redis
spring.redis.port=6379
3. 编写controller代码：
@RestController
public class MyController {
@Autowired
StringRedisTemplate stringRedisTemplate;
@RequestMapping("hello")
public String hello(){
Long counter = stringRedisTemplate.opsForValue().increment("counter");
return "页面访问次数"+counter;
}
}
4. 编写dockerfile文件
FROM java:8
COPY springcount-0.0.1-SNAPSHOT.jar app.jar
CMD ["--server.port=8080"]
EXPOSE 8086
ENTRYPOINT ["java","-jar","app.jar"]
5. 编写compose文件
version: '3.9'
services:
myapp:
build: .
image: myapp
depends_on:
- redis
ports:
- "8080:8080"
redis:
image: "library/redis:alpine"vivi
6. 将项目打包为jar
7. 创建目录上传jar包和dockerfile文件以及yml文件
8. 运行compose，执行命令：
docker-compose up9. 访问地址：http://192.168.56.30:8080/hello
Compose常见操作
(1)查看版本
docker-compose version
(2)根据yml创建service
docker-compose up
指定yaml：
docker-compose up -f xxx.yaml
后台运行：
docker-compose up -d
(3)查看启动成功的service
docker-compose ps
也可以使用docker ps
(4)查看images
docker-compose images
(5)停止/启动service
docker-compose stop/start
(6)删除service[同时会删除掉network和volume]
docker-compose down
(7)进入到某个service
docker-compose exec redis sh
Harbor私服
简介
Docker容器应用的开发和运行离不开可靠的镜像管理，虽然Docker官方也提供了公共的镜像仓库， 但是从安全和效率等方面考虑，部署我们私有环境内的Registry也是非常必要的。Harbor是由VMware 公司开源的企业级的Docker Registry管理项目，它包括权限管理(RBAC)、LDAP、日志审核、管理界 面、自我注册、镜像复制和中文支持等功能。
功能介绍
安装
官网安装教程：https://goharbor.io/docs/2.3.0/install-config/
首先需要下载对于的安装文件：Releases · goharbor/harbor · GitHub
因为比较大，从官网下载很慢，所以会在附近中直接给大家提供，使用最新的2.3.3版本
1. 进入目录下，创建文件，上传文件
cd /usr/local/ 2. 解压文件
tar -zxvf harbor-offline-installer-v2.3.3.tgz3. 将yml重命名
cd harbor
mv harbor.yml.tmpl harbor.yml 4. 配置https访问
生成CA证书私钥
openssl genrsa -out ca.key 4096配置域名
openssl req -x509 -new -nodes -sha512 -days 3650 \
-subj "/C=CN/ST=Beijing/L=Beijing/O=example/OU=Personal/CN=192.168.56.30" \
-key ca.key \
-out ca.crt
5. 生成私钥
openssl genrsa -out 192.168.56.30.key 40966. 生成证书签名请求（CSR）
openssl req -sha512 -new \
-subj "/C=CN/ST=Beijing/L=Beijing/O=example/OU=Personal/CN=192.168.56.30" \
-key 192.168.56.30.key \
-out 192.168.56.30.csr
7. 生成一个x509 v3扩展文件
无论您使用FQDN还是IP地址连接到Harbor主机，都必须创建此文件，以便可以为您的Harbor主机生成 符合主题备用名称（SAN）和x509 v3的证书扩展要求。替换 DNS 条目以反映您的域
cat > v3.ext <<-EOF
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment,
dataEncipherment
extendedKeyUsage = serverAuth
subjectAltName = IP:192.168.56.30
EOF
8. 使用该 v3.ext 文件为您的Harbor主机生成证书
vi v3.ext替换内容：
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, nonRepudiation, keyEncipherment,dataEncipherment
extendedKeyUsage = serverAuth
subjectAltName = IP:192.168.56.40
openssl x509 -req -sha512 -days 3650 \
-extfile v3.ext \
-CA ca.crt -CAkey ca.key -CAcreateserial \
-in 192.168.56.30.csr \
-out 192.168.56.30.crt
9. 提供证书给Harbor和Docker 生成后 ca.crt ， harbor.od.com.crt 和 harbor.od.com.key 文件，必须将它们提供给 Harbor 和 docker ，重新配置它们 将服务器证书和密钥复制到Harbor主机上的 /data/cert/ 文件夹中
mkdir -p /data/cert
cp 192.168.56.30.crt /data/cert/
cp 192.168.56.30.key /data//cert/
10. 转换 harbor.od.com.crt 为 harbor.od.com.cert ，供Docker使用
openssl x509 -inform PEM -in 192.168.56.30.crt -out 192.168.56.30.cert11. 将服务器证书，密钥和CA文件复制到Harbor主机上的Docker证书文件夹中。您必须首先创建适当的文件夹，执行命令：
mkdir -p /etc/docker/certs.d/192.168.56.30/
cp 192.168.56.30.cert /etc/docker/certs.d/192.168.56.30/
cp 192.168.56.30.key /etc/docker/certs.d/192.168.56.30/
cp ca.crt /etc/docker/certs.d/192.168.56.30/
12. 重启docker容器
systemctl restart docker13. 配置harbor服务，修改harbor.yml文件
cd /usr/local/harbor
vim harbor.yml
14. 修改配置文件
vi /data/cert
15. 初始化harbor服务
sh install.sh16. 浏览器访问：
https://192.168.56.30/
账号：admin
密码：Harbor12345
登录和镜像拉取
1. 创建项目
2. 点击项目名称
3. 点击成员、用户
4. 选择用户，维护用户角色
5. 登录私服
docker login 私服域名
输入用户名密码
6. 重命名镜像
docker tag redis:latest 192.68.56.40/dpb/redis-dpb:1.0推送镜像
docker push 192.68.56.40/dpb/redis-dpb:1.0swarm
Swarm是Docker官方提供的一款集群管理工具，其主要作用是把若干台Docker主机抽象为一个整 体，并且通过一个入口统一管理这些Docker主机上的各种Docker资源。Swarm和Kubernetes比较类 似，但是更加轻，具有的功能也较kubernetes更少一些
管理节点
管理节点处理集群管理任务：
维护集群状态
调度服务
服务群模式HTTP API 端点
使用 Raft 实现，管理器维护整个 swarm 及其上运行的所有服务的一致内部状态。出于测试目的， 可以使用单个管理器运行 swarm。如果单管理器群中的管理器出现故障，您的服务会继续运行，但您需 要创建一个新集群来恢复。
为了利用 swarm 模式的容错特性，Docker 建议您根据组织的高可用性要求实现奇数个节点。当您有多 个管理器时，您可以在不停机的情况下从管理器节点的故障中恢复。
三个管理器的群体最多可以容忍一个管理器的损失。
一个五管理器群可以容忍最大同时丢失两个管理器节点。
一个 N 管理器集群最多可以容忍管理器的丢失 (N-1)/2 。
Docker 建议一个群最多有七个管理器节点。
工作节点
工作节点也是 Docker 引擎的实例，其唯一目的是执行容器。Worker 节点不参与 Raft 分布式状 态，不做出调度决策，也不为 swarm 模式 HTTP API 提供服务。 您可以创建一个由一个管理器节点组成的群，但是如果没有至少一个管理器节点，您就不能拥有一个工 作节点。默认情况下，所有经理也是工人。在单个管理器节点集群中，您可以运行类似命令 docker service create ，调度程序将所有任务放在本地引擎上。
为防止调度程序将任务放置在多节点群中的管理器节点上，请将管理器节点的可用性设置为 Drain 。调 度器在 Drain mode 中优雅地停止节点上的任务并调度 Active 节点上的任务 。调度程序不会将新任务 分配给具有 Drain 可用性的节点。
Swarm集群搭建
环境准备
准备3个节点，通过vagrant新增加两个节点
需要单独指定hostname 修改Vagrantfile文件
config.vm.hostname=”work01-node”
还有就是每个节点需要具备Docker环境
搭建集群环境
1. 需要单独指定hostname 修改Vagrantfile文件
config.vm.hostname="work01-node"2. 初始化swram
docker swarm init --advertise-addr 192.168.56.50
docker swarm init --advertise-addr 192.168.56.60
docker swarm init --advertise-addr 192.168.56.70
3. 在manager节点执行命令：
docker swarm init --advertise-addr 192.168.56.504. 在另外的两个节点中执行命令：
docker swarm join --token SWMTKN-1-435rvyvj7py1xiwsycyuawh1tejhtxxr3u9ovldykoijohxqcb-co2m3e2kbo6igvesxj5w5bxva 192.168.56.50:2377docker swarm join --token SWMTKN-1-435rvyvj7py1xiwsycyuawh1tejhtxxr3u9ovldykoijohxqcb-co2m3e2kbo6igvesxj5w5bxva 192.168.56.50:23775. 在manager节点执行命令查看node节点：
Tomcat服务编排
拉取tomcat镜像
docker pull tomcat创建tomcat的服务
docker service create --name my-tomcat tomcat查看当前swarm的service
docker service ls查看service的启动日志
docker service logs my-tomcat查看service的详情
docker service inspect my-tomcat查看my-tomcat运行在哪个node上
docker service ps my-tomcat水平扩展service，将tomcat扩展至三台
docker service scale my-tomcat=3
docker service ls
docker service ps my-tomcat
日志 ：可以发现，其他node上都运行了一个my-tomcat的service
此时到worker01-node上：docker ps，可以发现container的name和service名称不一样，这点要知道
如果某个node上的my-tomcat挂掉了，这时候会自动扩展
删除service
docker service rm my-tomcatWordpress实战
1. 创建网络
docker network create -d overlay my-overlay-net2. 创建mysql
docker service create --name mysql --mount type=volume,source=v1,destination=/var/lib/mysql --env MYSQL_ROOT_PASSWORD=examplepass --env MYSQL_DATABASE=db_wordpress --network my-overlay-net mysql:5.63. 创建WordPress的Service
docker service create --name wordpress --env WORDPRESS_DB_USER=root --env WORDPRESS_DB_PASSWORD=examplepass --env WORDPRESS_DB_HOST=mysql:3306 --env WORDPRESS_DB_NAME=db_wordpress -p 8080:80 --network my-overlay-net wordpress4.访问测试
http:192.168.56.50:8080/wp-admin/
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/116519.html
