一、关于Docker

1.1为什么要用docker？

随着开发的项目越来越复杂，软件越来越多，服务器越来越多，我们在开发和部署的时候会遇到很多问题，比如：

1.不同的应用程序可能会有不同的应用环境，比如Java开发的网站和php开发的网站依赖的软件就不一样，如果把他们依赖的软件都安装在一个服务器上就要调试很久，而且很麻烦，还会造成一些冲突。比如tomcat和Apache访问端口冲突。这个时候你就要隔离Java开发的网站和php开发的网站。常规来讲，我们可以在服务器上创建不同的虚拟机在不同的虚拟机上放置不同的应用，但是虚拟机开销比较高。

2.你开发软件的时候用的是Ubuntu，但是运维管理的都是centos，运维在把你的软件从开发环境转移到生产环境的时候就会遇到一些Ubuntu转centos的问题，比如：有个特殊版本的数据库，只有Ubuntu支持，centos不支持，在转移的过程当中运维就得想办法解决这样的问题。

3.我们部署一台服务器就需要安装和配置很多环境，在分布式环境中，需要部署很多台，每台都完全安装和部署一次太麻烦。

那么怎么解决呢？我们可以用Docker！

Docker可以把开发环境直接封装转移给运维，运维直接部署封装后的环境就可以，而且docker可以实现虚拟机隔离应用环境的功能，并且开销比虚拟机小。

1.2 什么是docker

docker是一个开源的应用容器引擎，开发者可以打包自己的应用到容器里面，然后迁移到其他机器的docker应用中，可以实现快速部署。如果出现的故障，可以通过镜像，快速恢复服务。

1.3 docker的思想

1.Docker采用集装箱思想
  意思是将需要的内容和环境打包成一个个集装箱，所有的集装箱都可以上传到码头上，当有人需要某个环境时，就从码头上拉取这个集装箱就可以。码头的概念类似Maven仓库。
  
2.Docker的隔离性
  docker在运行集装箱中的内容时，会在linux内核中，单独的开辟一个单元，不会影响到其它程序。
  
3.Docker的标准化
  docker提供了一系列的命令，帮助我们去创建，拉取集装箱。

1.4 底层原理

docker是利用Linux内核虚拟机化技术（LXC），提供轻量级的虚拟化，以便隔离进程和资源。LXC不是硬件的虚拟化，而是Linux内核的级别的虚拟机化，相对于传统的虚拟机，节省了很多硬件资源。

NameSpace

LXC是利用内核namespace技术，进行进程隔离。其中pid, net, ipc, mnt, uts 等namespace将container的进程, 网络, 消息, 文件系统和hostname 隔离开。

Control Group

LXC利用的宿主机共享的资源，虽然用namespace进行隔离，但是资源使用没有收到限制，这里就需要用到Control Group技术，对资源使用进行限制，设定优先级，资源控制等。

1.5 版本支持

在CentOS6.8是可以支持docker，但是有些特性无法使用，因此至少使用3.8的内核版本，建议是使用3.10版本以上。国内生产环境很多都是使用CentOS，所以一般使用CentOS7即可。
当然如果是Ubuntu/Debian/Deepin系列的发行版本也是支持的。

二、 Docker安装和配置

2.1 环境准备

操作系统：CentOS

软件源：阿里云镜像（在阿里云镜像站上面可以找到docker-ce的软件源，使用国内的源速度比较快）

2.2 安装docker

1、安装依赖

docker依赖于系统的一些必要的工具，可以提前安装。

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

2、添加软件源

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

3、安装docker-ce

yum clean all #yum 会把下载的软件包和header存储在cache中而不自动删除。如果觉得占用磁盘空间，可以使用yum clean指令清除缓存。

yum makecache fast  #这个命令是将软件包信息提前在本地缓存一份，用来提高搜索安装软件的速度

yum -y install docker-ce

4、启动服务

通过systemctl启动服务

systemctl start docker

5、查看安装版本

这样子就安装成功了，启动服务以后可以使用docker version查看一下当前的版本。

docker version

6、设置开机自动启动

 systemctl enable docker

7、测试

docker run hello-world

2.3 仓库，镜像，容器的关系和区别

docker的整个生命周期有三部分组成：仓库（repository）+镜像（image）+容器（container）；

仓库

包含多个镜像文件的仓库，可以从仓库中拉取镜像，也可以将镜像发送到仓库中。

镜像

从仓库中拉取镜像，镜像是文件。这里的文件包含可执行文件， 依赖软件， 库文件， 配置文件等等。也就是一个镜像可以包含一个完整的linux操作系统环境，里面仅安装了mysql或用户需要的其他应用程序。

容器

由镜像创建容器，类似于给类实例化对象。docker容器类似虚拟机，可以执行包含启动，停止，删除等。每个容器间是相互隔离的。容器中会运行特定的运用，包含特定应用的代码及所需的依赖文件。可以把容器看作一个简易版的linux环境（包含root用户权限，进程空间，用户空间和网络空间等）和运行在其中的应用程序。

2.4 docker仓库

docker仓库就是前面我们说的码头，我们可以上传和拉取我们需要的环境。

1、国外仓库

地址： https://hub.docker.com/

? 这是docker官方仓库，仓库里的镜像文件是最全的，但服务器在国外，下载速度比较慢。

2、国内仓库

? 为了解决国外仓库下载速度慢的问题， 国内也有一些仓库，比如daoCloud

? daoCloud地址：https://hub.daocloud.io/

? 推荐使用国内仓库，速度更快

三 、Docker的使用

3.1 拉取镜像到本地

? 这里的容器就是前面说的集装箱

比如拉取tomcat+jre镜像

1.先找到tomcat+jre镜像的路径

2.拉取命令

 docker pull  daocloud.io/library/tomcat:8.5.16-jre8

3.查看已经拉取到本地的所有镜像

docker images

3.2 容器的使用

1.运行容器

docker run [options] 镜像名称|镜像标记

? 其中options可以为：

-d: 后台运行容器，并返回容器ID

-p:指定端口映射 格式：主机端口：容器端口

–name: 为容器指定一个名称

–volumn，-v：绑定一个卷

docker run -d -p 8081:8080 --name tomcat b2     #这里的b2是 tomcat对应的image id 的前2个字符

2.查看运行的容器

docker ps   #查看正在运行的容器

docker ps -a  #查看所有本地的容器 包含 未运行的

 docker ps  -q  # 查看正在运行的容器id

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9rNOZA90-1668525789400)(pic/22.png)]

3.启动容器

docker start 容器id

4.测试

浏览器输入： 服务器ip:8081

可看到tomcat首页

5.停止容器

docker stop 容器id   #停止指定容器
docker stop $(docker ps -qa)  #停止全部容器

6.删除容器

docker rm 容器id     #删除指定容器    删除前先停止

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

3.3.删除镜像

docker rmi  镜像id   #删除指定镜像
docker rmi -f $(docker images -qa)   #删除所有镜像

四、使用Docker部署项目

前面我们做了一个SpringBoot接口的案例，我们用Docker将SpringBoot案例打包成集装箱，部署到任何需要的地方。

SpringBoot项目运行需要用到Mysql，Tomcat，Jdk或Jre。

1、拉取Mysql容器

docker run -d -p 3306:3306 --name mysql  -e MYSQL_ROOT_PASSWORD=root   daocloud.io/library/mysql:5.7    

#-e MYSQL_ROOT_PASSWORD=root 设置root用户的密码
#如果之前运行过mysql容器则会出现端口占用或名称重复等问题，修改一下

测试连接：

导入数据库

2、拉取Tomcat+Jre容器

? 上一章已准备好

3、打包SpringBoot项目的war包，部署到tomcat中

3.1 修改项目中数据库配置信息

3.2 修改pom.xml文件

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
    <!-- 添加  移除嵌入式tomcat插件 -->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

3.3 修改入口类

springboot项目需要发布到外置tomcat时，需要extends SpringBootServletInitializer

3.4 打包成war

打开maven界面，先选择clean运行，再选择war.exploded运行，再选择package运行

可看到生成的war包

3.5 将war包复制到tomcat下的webapps目录下

? 先上传到linux系统中

? 修改war包名称，方便访问

复制war包到tomcat下的webapps目录下

docker cp swagger.war 容器id:/usr/local/tomcat/webapps/

这里的容器id:/usr/local/tomcat/webapps/ 是指容器中的webapps路径，那我们怎么知道它容器内部的路径是这个呢？

可以在docker仓库中去查看帮助文档

3.6 访问

浏览器输入网址：

http://服务器ip:8081/swagger/swagger-ui.html

这里面的swagger就是修改后的war包的名字

五、数据卷

1.数据卷是干什么的？

现在的问题是：

我们在部署项目的时候会将war包复制到容器内，运行中产生的数据都在容器中，一旦容器删除，数据就会丢失。如果部署很多容器，每次都需要进入容器中进行配置嘛？能不能外部进行配置，并实现数据共享？

我们的需求是：

我们希望数据可以持久化，即时删掉容器，我们的数据还在，Docker容器产生的数据，能同步到本地！
容器之间直接可以数据共享。

解决方案：

数据卷，也就是卷技术。
卷技术就是为了实现数据的持久化和同步操作，容器间也是可以数据共享的

2.数据卷的使用

2.1 创建数据卷

docker volume create  数据卷名称   #默认存放目录  /var/lib/docker/volumes

2.2 查看数据卷的详细信息

docker volume inspect 数据卷名

2.3 查看全部数据卷

docker volume ls

2.4 使用数据卷

关联数据卷和容器

方法1：

数据卷存放在默认目录下：/var/lib/docker/volumes

docker run -d -p 8081:8080 --name tomcat -v tomcat_vol:/usr/local/tomcat/webapps b2

# 创建tomcat容器和数据卷关联

方法2：

数据卷存放在指定目录下

docker run -d -p 8081:8080 --name tomcat -v
/volume/tomcat_vol:/usr/local/tomcat/webapps b2

#这里的/volume/tomcat_vol是自己指定的路径

复制war包到创建的数据卷目录下

启动tomcat容器

测试：

2.5 删除数据卷

docker volume rm 数据卷名称

六、自定义镜像

我们除了可以从仓库中拉取镜像，也可以自定义镜像，供别人拉取。

自定义镜像主要包含两个步骤，第一步是创建配置文件，配置镜像的内容，第二步是通过docker命令制作成镜像。

比如我们现在要自定义一个镜像，包含tomcat和swagger.war，并且将swagger.war部署到tomcat中，这样以后拉取这个自定义镜像以后可以直接访问网站，不需要再部署了。

1、创建Dockerfile文件，配置镜像内容

from daocloud.io/library/tomcat:8.5.16-jre8
copy swagger.war /usr/local/tomcat/webapps

注意：

from：是指定当前自定义镜像依赖的环境，比如这里的tomcat

copy：是将相对目录下的内容复制到依赖的环境下。

我这里swagger.war前没有目录，说明我是将swagger.war和Dockerfile放在同一个目录下。

Dockerfile可用的参数：

FROM: 指定当前自定义镜像依赖的环境,基础镜像
copy: 将相对路径下的内容复制到自定义镜像中
workdir: 声明镜像的默认工作目录
cmd: 需要执行的命令(在workdir下执行。cmd可以多个，但是以最后一个为准)
MAINTAINER 镜像作者	
RUN 构建是需要的命令
ADD 集成文件或者服务
VOLUME 数据卷
EXPOST 对外暴露的端口

2、将创建好的Dockerfile文件和swagger.war文件上传到服务器。

先在服务器上创建tomcat-swagger文件夹

上传两个文件到tomcat-swagger目录下

3、通过docker命令制作成镜像。

进入到tomcat-swagger目录，输入命令

docker build -t tomcat-swagger:1.0.0 .

# 1.0.0是自己设置的版本号
# 最后的 . 表示的是当前目录
# 将当前目录中的内容制作成镜像tomcat-swagger
# -t 指定镜像的名称和标签

4.运行自定义镜像

docker run -d -p 8082:8080 --name tomcat-swagger 92

5、测试

?

七 Docker-compose

docker-compose是编排容器的。例如，你有一个tomcat镜像，一个mysql镜像。如果没有docker-compose，那么每次启动的时候，你需要敲各个容器的启动参数，环境变量，容器命名，指定不同容器的链接参数等等一系列的操作，相当繁琐。而用了docker-composer之后，你就可以把这些命令一次性写在docker-composer.yml文件中，以后每次启动这一整个环境（tomcat+mysql）时候，你只要敲一个docker-composer up命令就可以了。

1、安装Docker-compose

1.1下载Docker-compose

登录https://github.com/，搜索docker-compose

1.2、安装和配置docker-compose

? 将下载的文件上传到linux系统中，并移动到/usr/local/bin目录下，修改名字为docker-compose

? 设置权限为可执行

   chmod 777 docker-compose

配置环境变量

1.3 测试

2.使用Docker-compose管理镜像

2.1 创建docker-compose.yml文件

version: '3.0'
services:
  wang_mysql:
    restart: always 
    image: daocloud.io/library/mysql:5.7 
    container_name: wang_mysql
    ports:
      - 3308:3306
    environment:
      MYSQL_ROOT_PASSWORD: root
      TZ: Asia/Shanghai
    volumes:
      - /wang/data/mysql_data:/var/lib/mysql
  my_tomcat:
    restart: always
    image: daocloud.io/library/tomcat:8.5.16-jre8
    container_name: my_tomcat
    ports:
      - 8083:8080
    environment:
      TZ: Asia/Shanghai
    volumes:
      - /wang/data/tomcat_webapps:/usr/local/tomcat/webapps
      - /wang/data/tomcat_logs:/usr/local/tomcat/logs

2.2 将docker-compose.yml上传到linux指定目录下

在linux系统中创建 /wang/data目录

?

上传文件

?

2.3 启动容器

进入/wang/data目录下：

docker-compose up -d

如果报错 修改后 重新运行

查看已经启动的容器

2.4 复制war包到tomcat数据卷中

2.5 测试

测试tomcat

测试mysql