容器引擎技术Docker

01. 初识 Docker

1.1 Docker 介绍

• Docker 是一个开源的应用容器引擎

• 诞生于 2013 年初，基于 Go 语言实现，由dotCloud 公司出品（后改名为Docker Inc）

• Docker 可以让开发者打包应用和相关软件到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上。

• 容器完全使用沙箱机制，相互之间完全隔离

• 容器性能开销极低。

• Docker 从 17.03 版本之后分为 CE（Community Edition: 社区版） 和 EE（Enterprise Edition: 企业版）

docker好处

不使用Docker

使用Docker

小结

• 使用Docker可以实现不同环境的一致性。
• 提高了运维效率

1.2 Docker 安装

目标：能够参考文档完成Docker的安装

Docker 可以运行在 MAC、Windows、CentOS、UBUNTU等操作系统上，提供社区版和企业版，本课程基于 CentOS7 安装Docker。

注意：建议安装在 CentOS7.x 以上的版本，在 CentOS6.x 的版本中，安装前需要安装其他很多的环境而且Docker很多补丁不支持更新。root itcast123

资料中备了安装好的镜像，使用VMWare直接挂载即可，挂载后，使用ifconfig命令查看本地ip，再通过自己的客户端去连接。

安装步骤

# 1.yum 更新已有rpm包，升级linux内核(不做也可以)
yum update

# 2.安装需要的软件包，yum-util提供yum-config-manager功能，另外两个是devicemapper驱动依赖
yum install -y yum-utils device-mapper-persistent-data lvm2

# 3.设置yum源为阿里云
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 4.安装docker【docker-ce: 社区版，免费；docker-ee：企业版，收费】
yum install docker-ce -y

# 5.安装后查看docker版本
docker -v

1.3 Docker 架构

名称	说明
Docker 镜像 (Images)	Docker 镜像是用于创建 Docker 容器的模板。镜像是基于联合文件系统的一种层式结构， 由一系列指令一步一步构建出来(只读不能修改)。
Docker 容器 (Container)	容器相当于一个小的操作系统。（镜像相当于类，容器相当于类的对象）
Docker 客户端(Client)	Docker 客户端通过命令行或者其他工具使用 Docker API 与 Docker 的守护进程通信。
Docker 主机(Host)	一个物理或者虚拟的机器用于安装Docker
Docker守护进程	是Docker服务端进程，负责支撑Docker容器的运行以及镜像的管理。
Docker 仓库 DockerHub(Registry)	Docker 仓库用来保存镜像，类似于github。 Docker Hub提供了庞大的镜像集合供使用。用户也可以将自己本地的镜像推送到Docker仓库供其他人下载。

1.4 Docker 镜像加速器

默认情况下，从docker hub（https://hub.docker.com/）上下载docker镜像，太慢。一般都会配置镜像加速器：

• USTC：中科大镜像加速器（https://docker.mirrors.ustc.edu.cn）

• 阿里云

• 网易云

• 腾讯云

操作步骤

1）创建并编辑文件 /etc/docker/daemon.json

# 执行如下命令
mkdir /etc/docker
cd /etc/docker
vi daemon.json  

2）在文件中加入下面内容:

{
"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}

02. Docker 命令

2.1 进程相关命令

# 启动docker服务
systemctl start docker
# 停止docker服务
systemctl stop docker
# 重启docker服务
systemctl restart docker
# 查看docker服务状态
systemctl status docker
# 设置开机启动docker服务
systemctl enable docker
# 设置开机不自动启动
systemctl disable docker
# 查看docker概要信息
docker info
# 查看docker帮助文档
docker --help

注意: systemctl命令是系统服务管理器指令。

2.2 镜像相关命令

2.2.1 查看镜像

# 查看镜像可以使用如下命令:
docker images

• REPOSITORY: 镜像名称
• TAG: 镜像标签 (默认是可以省略的, 也就是latest)
• IMAGE ID: 镜像ID
• CREATED: 镜像的创建日期（不是获取该镜像的日期）
• SIZE: 镜像大小

2.2.2 搜索镜像

# 如果你需要从公有仓库中查找需要的镜像，可以通过以下命令搜索
docker search 镜像名称

• NAME: 镜像名称
• DESCRIPTION: 镜像描述
• STARS: 用户评价，反应一个镜像的受欢迎程度
• OFFICIAL: 是否官方
• AUTOMATED: 自动构建，表示该镜像由Docker Hub自动构建流程创建的

大家也可以去官方搜索(http://hub.docker.com):

2.2.3 拉取镜像

# 拉取镜像就是从Docker仓库下载镜像到本地，镜像名称格式为 名称:版本号，如果版本号不指定则是最新的版本 命令如下:
docker pull 镜像名称

# 拉取centos 7
docker pull centos:7
# 拉取centos 最后版本镜像
docker pull centos:latest

2.2.4 删除镜像

# 按照镜像id删除镜像，或者镜像名称:版本号
docker rmi 镜像ID
# 删除所有镜像(谨慎操作)
docker rmi `docker images -q`

2.3 容器相关命令

2.3.1 查看容器

• 查看正在运行容器: docker ps

• 查看所有容器: docker ps -a

2.3.2 创建与运行容器

可以基于已有的镜像来创建容器，创建与运行容器使用命令: docker run

参数说明:

-i: 表示运行容器

-t: 表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端/bin/bash。

--name: 为创建的容器命名(名称不能重复)。

-v: 表示目录映射关系（前者是宿主机目录，后者是容器的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。

-d: 在run后面加上-d参数, 则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，并指定终端，创建后就会自动进去容器）。

-p: 表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射。

1）交互式容器

以交互式方式创建并运行容器，启动完成后，会直接进入当前容器。使用exit命令退出容器。以此种方式创建并启动容器，如果（第一次）退出容器，则容器会变成停止状态。

# 先拉取一个镜像，（已经拉取过）
docker pull centos:7

# 创建并启动名称为 mycentos7 的交互式容器
# 容器名称 mycentos7
# 镜像名称:TAG (centos:7)  也可以使用镜像id (5e35e350aded)
# /bin/bash: 进入容器命令行，分配一个终端
docker run -it --name=mycentos7 centos:7 /bin/bash

2）守互式容器

对于一个需要长期运行的容器来说，我们可以创建一个守护式容器，命令如下（容器名称不能重复）

# 创建并启动守护式容器
# 容器名称: mycentos2
# 镜像名称: TAG (centos:7)  也可以使用镜像id (5e35e350aded)
docker run -di --name=mycentos2 centos:7

# 进入容器：
docker exec -it container_name (或者 container_id) /bin/bash

说明: 守护式容器是一直运行的，退出只是退出终端，它还是在后台运行。

2.3.3 进入容器

# 进入容器, 容器必须是启动状态
docker exec -it mycentos2 /bin/bash

2.3.4 停止或启动容器

# 停止正在运行的容器: docker stop 容器名称|容器ID
docker stop mycentos2

# 启动已运行过的容器: docker start 容器名称|容器ID
docker start mycentos2

2.3.5 重启容器

# 重启正在运行的容器: docker restart 容器名称|容器ID
docker restart mycentos2

2.3.6 查看容器信息

# 在linux宿主机下查看 mycentos2 的ip
# docker inspect 容器名称（容器ID）
docker inspect mycentos2

容器之间在一个局域网内，linux宿主机器可以与容器进行通信；但是外部的服务器是不能与容器直接通信的，如果需要则需要通过宿主机器端口的代理。

2.3.7 删除容器

• 删除指定的容器: docker rm 容器名称|容器ID
• 删除所有容器: docker rm `docker ps -a -q`

# 删除指定容器
docker rm mycentos2

# 删除所有容器
docker rm `docker ps -a -q`

说明: 如果容器是运行状态则删除失败，需要停止容器才能删除

2.4 文件拷贝命令

目标：能够熟练运用docker文件拷贝命令

2.4.1 宿主机到容器

# docker cp 需要拷贝的文件或目录 容器名称:容器目录

# 创建一个文件abc.txt 
touch abc.txt

# 复制 abc.txt 到 mycentos2 的容器的 / 目录下 
docker cp abc.txt mycentos2:/ 

# 进入mycentos2容器 
docker exec -it mycentos2 /bin/bash 

# 查看容器 / 目录下文件
ll

2.4.2 容器到宿主机

# docker cp 容器名称:容器目录 需要拷贝的文件或目录

# 进入容器后创建文件aaa.txt
touch aaa.txt

# 退出容器
exit

# 在Linux宿主机器执行复制；将容器mycentos2的/aaa.txt文件复制到 宿主机器的/root目录下
docker cp mycentos2:/aaa.txt /root

注意: 停止状态的容器也是可以进行文件拷贝的，可以拷进去，也可以拷出来。

03. Docker 容器的数据卷

3.1 数据卷概念及作用

数据卷就可以解决以上三个问题

数据卷概念

• 数据卷是宿主机中的一个目录或文件
• 当容器目录和数据卷目录绑定后，对方的修改会立即同步
• 一个数据卷可以被多个容器同时挂载
• 一个容器也可以被挂载多个数据卷

数据卷作用

• 容器数据持久化
• 外部机器和容器交换文件
• 容器之间文件交换

3.2 配置数据卷

可以在创建容器的时候，通过-v 参数将宿主机的目录与容器内的目录进行映射，这样我们就可以通过修改宿主机某个目录的文件从而去影响容器。

# 创建并启动容器mycentos3
# 并挂载linux宿主机中的/usr/local/test目录到容器的/usr/local/test
docker run -di -v /usr/local/test:/usr/local/test --name=mycentos3 centos:7

# 在linux宿主机下创建文件 
touch /usr/local/test/bbb.txt

# 进入容器 
docker exec -it mycentos3 /bin/bash

# 在容器中查看目录中是否有对应文件bbb.txt
cd /usr/local/test

ll

说明：如果你共享的是多级的目录，可能会出现权限不足的提示。 这是因为CentOS7中的安全模块selinux把权限禁掉了，需要添加参数 --privileged=true 来解决挂载的目录没有权限的问题。

注意事项：

• 目录必须是绝对路径
• 如果目录不存在，会自动创建
• 可以挂载多个数据卷

3.3 数据卷容器（了解）

使用步骤

1）创建启动c3数据卷容器，使用 –v 参数 设置数据卷

# /test 目录会默认和宿主机随机分配的目录（数据卷）进行映射
docker run -id --name=c3 -v /test centos:7 

2）创建启动 c1、c2 容器，使用 –-volumes-from 参数继承c3容器

# c1、c2容器内都会存在/test目录，并且相互映射
docker run -id --name=c1 --volumes-from c3  centos:7    
docker run -id --name=c2 --volumes-from c3  centos:7    

3）进入c1容器查看是否存在/test目录

# 进入c1容器
docker exec -it c1 /bin/bash
# 查看
ls

4）在c1容器的test目录下创建文件

# 进入test目录
cd test
# 创建文件
touch aaa.txt
# 查看
ls

5）exit 退出c1容器，再进入c2容器，查看是否有test目录，目录下是否有aaa.txt

# 退出c1容器
exit
# 进入c2容器
docker exec -it c2 /bin/bash
# 进入test目录
cd test
# 查看
ls

小结

• 数据卷概念：宿主机的一个目录或文件
• 数据卷作用
  • 容器数据持久化
  • 外部机器和容器文件交换
  • 容器间文件交换
• 数据卷容器：创建一个容器，挂载一个目录（数据卷），让其他容器继承自该容器( --volume-from )。

04. Docker 应用部署

4.1 mysql安装

4.1.1 拉取镜像

# 拉取MySQL 2.7镜像
docker pull centos/mysql-57-centos7

4.1.2 创建容器

# 创建mysql5.7容器 
docker run -di --name=mysql5.7 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root centos/mysql-57-centos7

• -p 代表端口映射，格式为 宿主机映射端口:容器运行端口
• -e 代表添加环境变量，MYSQL_ROOT_PASSWORD 是root用户的远程登陆密码

4.1.3 操作容器mysql

# 进入mysql5.7容器
docker exec -it mysql5.7 /bin/bash 

# 登录容器里面的mysql 
mysql -u root -p

也可使用SQLyog在windows中进行远程连接

4.2 tomcat安装

4.2.1 拉取镜像

# 拉取tomcat镜像
docker pull tomcat

4.3.2 创建容器

# 创建tomcat容器;并挂载了webapps目录
docker run -di --name=mytomcat -p 9000:8080 -v /usr/local/tomcat/webapps:/usr/local/tomcat/webapps tomcat

# 查看日志
docker logs -f mytomcat

# 如果出现 WARNING: IPv4 forwarding is disabled. Networking will not work. 
# 执行如下操作 
# 1、编辑 sysctl.conf 
vi /etc/sysctl.conf 

# 2、在上述打开的文件中后面添加 
net.ipv4.ip_forward=1

# 3、重启network
systemctl restart network

4.2.3 部署web应用

1）在刚刚的mysql数据库中创建springboot_db数据库，再创建tb_user表

2）修改springboot-high工程的application.yml（数据库连接池信息），使用mysql容器所在宿主机的ip和端口，如果使用的是mysql容器内的ip和端口，前提是两个容器必须在同一个宿主机下。

spring:
  datasource:
  driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.12.132:3306/springboot_db # 使用容器的ip端口或宿主机的ip端口
  username: root
    password: root

3） 修改springboot-high工程的pom文件

<packaging>warpackaging>
  

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-tomcatartifactId>
    <scope>providedscope>
dependency>


<build>
    <finalName>ROOTfinalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
        plugin>
    plugins>
build>

4）编写WebServletInitializer类，作用等价于web.xml

package cn.itcast.configuration;

import cn.itcast.HighApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

/**
 * 作用等价于web.xml
 *
 * @Author LK
 * @Date 2020/11/7
 */
public class WebServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        builder.sources(HighApplication.class);
        return builder;
    }
}

5）进入项目pom文件所在命令行下，执行打包命令: mvn clean package -Dmaven.test.skip=true

6）上传ROOT.war到 /usr/local/tomcat/webapps/ 目录下。

4.2.4 测试

浏览器访问 (http://192.168.12.132:9000/findAll)

4.3 Nginx安装

4.3.1 拉取镜像

# 拉取nginx镜像 
docker pull nginx

4.3.2 创建容器

# 创建nginx容器 
docker run -di --name=mynginx -p 80:80 nginx

# 查看日志
docker logs -f mynginx

访问 http://192.168.12.132:80

4.3.3 修改Nginx文件

1）配置反向代理，官方的nginx镜像，配置文件nginx.conf 在/etc/nginx/目录下。

资料中准备了nginx.conf，修改配置即可

server {
	listen 80;
	server_name 127.0.0.1;

	location / {
	    proxy_pass http://192.168.12.132:9000;
	}
} 

2）将修改后的配置文件拷贝到容器中

# 先上传nginx.config文件
# 复制配置文件
docker cp nginx.conf mynginx:/etc/nginx/nginx.conf

3）重新启动容器

docker restart mynginx

4.3.4 测试

访问(http://192.168.12.132/findAll)

4.4 Redis安装

目标：能够参考文档在docker中安装Redis

4.4.1 拉取镜像

# 拉取redis镜像
docker pull redis

4.4.2 创建容器

# 创建redis容器
docker run -di --name=myredis -p 6379:6379 redis

 # 查看redis日志
docker logs -f myredis 

4.4.3 操作Redis

# 进入redis容器
docker exec -it myredis /bin/bash 

# 进入redis安装目录 
cd /usr/local/bin

# 连接redis 
./redis-cli

也可以在外部代码中使用redis。

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.12.132:3306/springboot_db
    username: root
    password: root
  redis:
    host: 192.168.12.132 # 使用宿主机ip端口
    port: 6379

05. Docker 容器备份与迁移

目标: 掌握docker中容器的备份与迁移

主要作用: 就是让配置好的容器，可以得到复用，后面用到得的时候就不需要重新配置。

其中涉及到的命令有:

• docker commit 将容器保存为镜像
• docker save -o 将镜像备份为tar文件
• docker load -i 根据tar文件恢复为镜像

操作步骤

1）容器保存为镜像，命令格式： docker commit 容器名称 新的镜像名称

# 将容器保存为镜像
docker commit mynginx mynginx

说明: 此镜像的内容就是当前容器的内容，接下来你可以用此镜像再次运行新的容器.

2）镜像备份 (使用docker save命令可以将已有镜像保存为tar文件)，命令格式： docker save –o tar文件名 镜像名

# 保存镜像为文件 
docker save -o mynginx.tar mynginx

3）镜像恢复与迁移 (使用docker load命令可以根据tar文件恢复为docker镜像)，命令格式： docker load -i 文件名

# 删除已有的mynginx镜像，以免冲突
docker rmi mynginx 

# 加载恢复mynginx镜像 
docker load -i mynginx.tar 

# 在镜像恢复之后，可以基于该镜像再次创建启动容器，这次我们宿主机端口用81，别和之前的80冲突了
docker run -di --name=mynginx -p 81:80 mynginx

小结

• 容器保存镜像: docker commit 容器名称 新的镜像的名称
• 导出镜像: docker save -o 镜像名称.tar 新的镜像的名称
• 导入镜像: docker load -i 镜像名称.tar

06. Dockerfile（了解）

目标: 掌握Dockerfile构建镜像

6.1 Docker 镜像原理

• Docker镜像是由特殊的文件系统叠加而成
• 最底端是 bootfs，并使用宿主机的bootfs，因此在宿主机上创建的容器内核必须和宿主机一样
• 第二层是 root文件系统rootfs，称为base image
• 往上可以叠加其他的镜像文件
• 统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，这样就隐藏了多层
• 的存在，在用户的角度看来，只存在一个文件系统。
• 一个镜像可以放在另一个镜像的上面。位于下面的镜像称为父镜像，最底部的镜像成为基础镜像。
• 当从一个镜像启动容器时，Docker会在最顶层加载一个读写文件系统作为容器

Docker 镜像如何制作？

• 将一个已有的容器保存为镜像

• Dockerfile

6.2 Dockerfile 概念及用法

• Dockerfile 是一个文本文件
• 包含了一条条的指令
• 每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像
• Docke hub网址：https://hub.docker.com 上提供了很多镜像，包括镜像的dockerfile

• Dockerfile文件内容一般分为4部分
  • 基础镜像信息
  • 维护者信息
  • 镜像操作指令
  • 容器启动时执行的指令

命令	作用
FROM image_name:tag	定义了使用哪个基础镜像启动构建流程
MAINTAINER user_name	声明镜像的创建者
ENV key value	设置环境变量 (可以写多条)
RUN command	是Dockerfile的核心部分(可以写多条)
ADD source_dir/file dest_dir/file	将宿主机的文件复制到镜像内，如果是一个压缩文件，将会在复制后自动解压
COPY source_dir/file dest_dir/file	和ADD相似，但是如果有压缩文件并不能解压
WORKDIR path_dir	设置工作目录

6.3 案例

需求：基于centos7镜像，自定义一个包含jdk、springboot项目的镜像

# 1、创建目录，将定义进行需要的资料到放到该目录下 
mkdir -p /usr/local/dockerdemo
cd /usr/local/dockerdemo 

# 2、上传jdk-8u171-linux-x64.tar.gz、springboot.jar包到宿主机中的/usr/local/dockerdemo 

# 3、创建Dockerfile文件
vi Dockerfile

# Dockerfile文件内容
FROM centos:7  # 指定基础镜像
MAINTAINER ITCAST  # 定义作者信息
WORKDIR /usr     # 定义工作目录，创建容器并运行时，如果进入容器，默认到该目录下
RUN mkdir /usr/local/java    # 在镜像中创建一个文件夹
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java/   # 添加jdk安装包到目标目录下，并自动解压
ADD springboot.jar /usr/local/springboot.jar  # 添加springboot.jar包指定到目标目录下
EXPOSE 8080   # 指定要暴露的端口，方便运行容器时指定端口映射
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171   # 设置JDK环境变量
ENV PATH $JAVA_HOME/bin:$PATH   # 设置JDK环境变量
CMD java -jar /usr/local/springboot.jar  # 根据构建的镜像，创建为容器，并运行时，会自动执行该命令，启动springboot项目


# 4、执行命令构建镜像；不要忘了后面的那个 . （点代表当前目录）
# -t 指定镜像名称，还可以使用-f 指定Dockerfile文件名称
docker build -t='springbootdemo' .

# 5、查看镜像是否建立完成 
docker images

基于刚刚创建的镜像创建并启动容器进行测试

# 创建并启动容器 
docker run -id --name=myspringbootdemo -p 8081:8080 springbootdemo

# 查看日志
docker logs myspringbootdemo

浏览器访问项目：http://宿主机ip:宿主机端口/映射

07. Docker 私有仓库

7.1 私有仓库搭建与配置

Docker官方的Docker hub（https://hub.docker.com）是一个用于管理公共镜像的仓库，我们可以从上面拉取镜像到本地，也可以把我们自己的镜像推送上去。但是，有时候我们的服务器无法访问互联网，或者你不希望将自己的镜像放到公网当中，那么我们就需要搭建自己的私有仓库来存储和管理自己的镜像。

# 1、拉取私有仓库镜像 
docker pull registry

# 2、启动私有仓库容器
docker run -di --name=registry -p 5000:5000 registry 

# 3、打开浏览器 输入地址http://宿主机ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库 搭建成功 

# 4、假设现在是另一台服务器，修改daemon.json
vi /etc/docker/daemon.json
# 在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将宿主机ip修改为自己宿主 机真实ip 
{"insecure-registries":["宿主机ip:5000"]} 

# 5、重启docker 服务 
systemctl restart docker 

# 因为现在只有一台服务器，我们重启了docker把registry容器也停掉了，因此我们启动下registry容器
docker start registry

访问: http://192.168.253.128:5000/v2/_catalog

7.2 上传镜像到私有仓库

# 1、标记镜像为私有仓库的镜像 
# 语法: docker tag 镜像名 宿主机IP:5000/镜像名
docker tag springbootdemo 192.168.12.132:5000/springbootdemo


# 2、上传标记的镜像到私有仓库
# 语法: docker push 宿主机IP:5000/jdk1.8 
docker push 192.168.12.132:5000/springbootdemo

# 3、输入网址查看仓库效果 http://192.168.12.132:5000/v2/_catalog  

7.3 从私有仓库拉取镜像

若是在私有仓库所在的服务器上去拉取镜像；那么直接执行如下命令:

# 因为私有仓库所在的服务器上已经存在相关镜像；所以先删除；请指定镜像名，不是id 
# 语法: docker rmi 服务器ip:5000/springbootdemo
docker rmi 192.168.12.132:5000/springbootdemo

# 拉取镜像 
# 语法: docker pull 服务器ip:5000/springbootdemo
docker pull 192.168.12.132:5000/springbootdemo

#可以通过如下命令查看 docker 的信息；了解到私有仓库地址 
docker info