此文档来源于网络,如有侵权，请联系删除！

前言

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux 或 Windows 操作系统的机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。

一、初识Docker

1.初识Docker-Docker概述

• Docker是一个开源的应用容器引擎
• 诞生于2013年初，基于Go 语言实现，dotCloud公司出品（后改名为Docker lnc）
• Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上。
• 容器时完全使用沙箱机制，相互隔离
• 容器性能开销极低
• Docker从17.03版本之后分为CE（Community Edition：社区版）和 EE（Enterprise Edition：企业版）

小结：Docker是一种容器技术，解决软件跨环境迁移的问题

2.初识Docker-安装Docker

Docker可以运行在MAC、Windows、CentOS、UBUNTU等操作系统上，本文基于CentOS7安装Docker。

• 官网：https://www.docker.com/

使用官方安装脚本自动安装

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun
1

查看Docker版本（验证是否安装成功）

docker -v
1

3.初识Docker-Docker架构

Docker 包括三个基本概念：

• 镜像（lmage）：Docker镜像（lmage），就相当于是个root文件系统。比如官方镜像Ubuntu:16.04就包含了完整的一套Ubuntu16.04最小系统的root文件系统。
• 容器（Container）：镜像（lmage）和容器（Container）的关系，就像是面向对象程序设计中的类和对象一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等。
• 仓库（Repository）：仓库可看成一个代码控制中心，用来保存镜像。

Docker 使用客户端-服务器 (C/S) 架构模式，使用远程API来管理和创建Docker容器。
Docker 容器通过 Docker 镜像来创建。

容器与镜像的关系类似于面向对象编程中的对象与类。

4.初识Docker-配置镜像加速器

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

国内从 DockerHub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。Docker 官方和国内很多云服务商都提供了国内加速器服务，例如：

• 科大镜像：https://docker.mirrors.ustc.edu.cn/
• 网易：https://hub-mirror.c.163.com/
• 七牛云加速器：https://reg-mirror.qiniu.com
• 阿里云：https://<你的ID>.mirror.aliyuncs.com

我们这边配置阿里云镜像加速器

阿里云官网：https://www.aliyun.com/

1.访问阿里云官网→登录阿里云（没有阿里云账号就先注册在登录）

2.控制台→三条横杆→搜索 “镜像” →容器镜像服务

3.镜像工具→镜像加速器

4.选择自己安装的系统版本→复制命令粘贴执行

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://<你的ID>.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
1
2
3
4
5
6
7
8

注意：一次性全部复制粘贴，最后一行命令会没有粘贴成功，注意查看，将最后一行命令重新复制粘贴执行即可

二、Docker命令

1.Docker命令-服务相关命令

• 启动Docker服务

  systemctl start docker
  1

• 停止Docker服务

  systemctl stop docker
  1

• 重启Docker服务

  systemctl restart docker
  1

• 查看Docker服务状态

  systemctl status docker
  1

• 开机启动Docker服务（设置开机自启）

  systemctl enable docker
  1

2.Docker命令-镜像相关命令

• 查看镜像

  docker images	#docker images 列出本地主机上的镜像。
  1

  

  各个选项说明：

  选项名称	说明
  REPOSITORY	表示镜像的仓库源
  TAG	镜像的标签
  IMAGE ID	镜像ID
  CREATED	镜像创建时间
  SIZE	镜像大小

  查看所有镜像的IMAGE ID

  #查看所有镜像的IMAGE ID
  docker images -q
  1
  2

  

• 搜索镜像

  比如我们需要一个 httpd 的镜像来作为我们的 web 服务。我们可以通过 docker search 命令搜索 httpd 来寻找适合我们的镜像。

  docker search 镜像名		#从网络中查找需要的镜像
  1

  

  各个选项说明：

  选项名称	说明
  NAME	镜像仓库源的名称
  DESCRIPTION	镜像的描述
  STARS	类似 Github 里面的 star，表示点赞、喜欢的意思
  OFFICIAL	是否 docker 官方发布
  AUTOMATED	自动构建

• 拉取镜像

当我们在本地主机上使用一个不存在的镜像时 Docker 就会自动下载这个镜像。如果我们想预先下载这个镜像，我们可以使用 docker pull 命令来下载它。

docker pull 镜像名:版本号	#不跟:版本号，会自动下载最新的版本latest
1

例子

docker pull redis
1

docker pull redis:5.0
1

#查看本地主机上的镜像。
docker images
1
2

想知道有哪些镜像版本可以下载，可以去官网搜索查看：http://hub.docker.com/

• 删除镜像

方法一（根据IMAGE ID删除）

docker rmi IMAGE ID
1

例子

docker rmi 7614ae9453d1
1

方法二（根据镜像名+版本号删除）

docker rmi redis:5.0	#有的时候IMAGE ID会重复，导致报错，可以使用这个方法删除
1

方法三（删除全部）

#查看所有镜像的IMAGE ID
docker images -q
1
2

#删除所有镜像（相当于把docker images -q命令执行	的结果当成参数去删除）
docker rmi `docker images -q`
1
2

3.Docker命令-容器相关命令

• 查看容器

语法：

docker ps [OPTIONS]
1

OPTIONS说明：

实例

#列出所有在运行的容器信息
docker ps
1
2

#列出所有未运行、在运行的容器信息
docker ps -a
1
2

输出详情介绍：

• 创建容器

docker run ：创建一个新的容器并运行一个命令

语法：

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
1

OPTIONS说明：

实例

docker run -it --name=mycentos centos:7 /bin/bash
1

docker run -id --name=mycentos1 centos:7 /bin/bash
1

说明：

①使用-it这两个参数后，容器创建后自动进入容器中，退出容器后，容器自动关闭
②使用-d参数后，需要使用docke rexec进入容器。退出后，容器不会关闭。
③-it创建的容器一般称为交互式容器，-id创建的容器一般称为守护式容器

• 进入容器

在使用 -d 参数时，容器启动后会进入后台。此时想要进入容器，可以通过以下指令进入：

docker attach：连接到正在运行中的容器。
语法：

docker attach [OPTIONS] CONTAINER
1

实例

注意： 如果从这个容器退出，会导致容器的停止。

docker exec：在运行的容器中执行命令。推荐大家使用 docker exec 命令，因为此命令会退出容器终端，但不会导致容器的停止。
语法：

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
1

OPTIONS说明：

实例

docker exec -it mycentos1 /bin/bash
1

注意： 如果从这个容器退出，容器不会停止，这就是为什么推荐大家使用 docker exec 的原因。

• 启动容器

#使用 docker start 启动一个已停止的容器
docker start 容器名|容器 ID	
1
2

• 停止容器

#使用 docker stop 停止一个正在运行的容器
docker stop 容器名|容器 ID
1
2

• 重启容器

docker restart 容器名|容器 ID
1

• 删除容器

docker rm 容器名|容器 ID
1

• 查看容器信息

docker inspect : 获取容器/镜像的元数据。

语法：

docker inspect [OPTIONS] NAME|ID [NAME|ID...]
1

OPTIONS说明：

三、Docker容器的数据卷

1.Docker容器数据卷-数据卷概念及作用

思考：

• Docker容器删除后，在容器中产生的数据也会随之销毁
• Docker 容器和外部机器可以直接交换文件吗?
• 容器之间想要进行数据交互?

数据卷

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

数据卷概念

• 宿主机的一个目录或文件

数据卷作用

• 容器数据持久化
• 外部机器和容器间接通信
• 容器之间数据交换

2.Docker容器数据卷-配置数据卷

• 创建启动容器时，使用 -v 参数设置数据卷

docker run ... -v 宿主机目录(文件):容器内目录(文件) ...
1

• 注意事项：
  • 1.目录必须是绝对路径
  • 2.如果目录不存在，会自动创建
  • 3.可以挂载多个数据卷

实例：创建容器配置数据卷（外部机器和容器间接通信）

docker run -it --name=centos1 -v /root/data:/root/data_container centos:7 /bin/bash
1

当容器目录和数据卷目录绑定后，对方的修改会立即同步

实例：删除容器后重新挂载容器（容器数据持久化）

实例：一个容器挂载多个目录

实例：两个容器挂载到同一个目录（实现容器之间数据交换）

1.创建一个容器挂载到 /root/data 目录下

2. 查看容器 /root/data 目录下的内容

3. 打开一个新的会话窗口，再创建一个容器挂载到 /root/data 目录下，添加内容到test.txt文件中

4. 回到第一个会话窗口会，查看test.txt文件会发现当前容器目录下也添加了内容

3.Docker容器数据卷-数据卷容器

多个容器进行数据交换

1. 多个容器挂载同一个数据卷
2. 数据卷容器

数据卷容器

• 创建一个容器，挂载一个目录，让其他容器继承自该容器（–volumes-from）
• 通过简单方式实现数据卷配置

配置数据卷容器

1. 创建启动 centos3 数据卷容器，使用 -v 参数设置数据卷

   docker run -it --name=centos3 -v /volume centos:7 bin/bash
   1

   
   

2. 创建启动 centos1 centos2 容器，使用 --volumes-from 参数设置数据卷（使用新的会话窗口）

   docker run -it --name=centos1 --volumes-from centos3 centos:7 bin/bash
   docker run -it --name=centos2 --volumes-from centos3 centos:7 bin/bash
   1
   2

   
   

3. 测试（在 centos1 centos2 任意一个容器的volume目录下创建文件，centos1 centos2 centos3的volume目录下都会生成对应的文件）

四、Docker应用部署

1.Docker应用部署-部署MySQL

• 案例需求：在Docker容器中部署MySQL，并通过外部MySQL客户端操作MySQL服务

• 案例实现步骤：

  ①搜索MySQL镜像

  ②拉取MySQL镜像

  ③创建容器

  ④操作容器中的MySQL

MySQL部署

• 容器内的网络服务和外部机器不能直接通信
• 外部机器和宿主机可以直接通信
• 宿主机和容器可以直接通信
• 当容器中的网络服务需要被外部机器访问时，可以将容器中提供服务的端口映射到宿主机的端口上。外部机器访问宿主机的该端口，从而间接访问容器的服务。
• 这种操作称为：端口映射

一、搜索MySQL镜像

docker search mysql
1

二、拉取MySQL镜像

docker pull mysql:latest
1

三、查看本地镜像

docker images
1

四、在 /root 目录下创建mysql目录用于存储mysql数据信息，进入到mysql目录中

#创建mysql目录
mkdir mysql
#进入到mysql目录
cd mysql
1
2
3
4

五、创建容器，设置端口映射、目录映射

docker run -id \
-p 3306:3306 \
--name=mysql-test \
-v $PWD/conf:/etc/mysql/conf.d \
-v $PWD/logs:/logs \
-v $PWD/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 \
mysql:latest
1
2
3
4
5
6
7
8

• 参数说明
  • -p 3306:3306：映射容器服务的 3306 端口到宿主机的 3306 端口，外部主机可以直接通过 宿主机 ip:3306 访问到 MySQL 的服务。冒号前面代表的是宿主机端口号。
  • -v $PWD/conf:/etc/mysql/conf.d：将主机当前目录下的 conf/my.cnf 挂载到容器的 /etc/mysql/my.cnf。配置目录
  • -v $PWD/logs:/logs：将主机当前目录下的 logs 目录挂载到容器的 /logs。日志目录
  • -v $PWD/data:/var/lib/mysql： 将主机当前目录下的data目录挂载到容器的 /var/lib/mysql。数据目录
  • MYSQL_ROOT_PASSWORD=123456：设置 MySQL 服务 root 用户的密码。

六、进入到MySQL容器中

docker exec -it mysql-test /bin/bash
1

七、登录MySQL

mysql -uroot -p123456
1

外部访问Doker中的MySQL容器

1.使用Windows的cmd窗口远程连接

2.使用DataGrip 连接

3.使用navicat连接（由于navicat版本问题连接报错）

远程连接Docker中的MySQL容器注意事项

1. 确保MySQL开放了远程连接的权限

   执行查询语句，查看数据库当前的访问权限的信息

   select  User,authentication_string,Host from user;
   1

   

2. 确保Docker宿主机防火墙开放了MySQL的端口号或者直接关闭防火墙

2.Docker应用部署-部署Tomcat

• 案例需求：在Docker容器中部署Tomcat，并通过外部机器访问Tomcat部署的项目。

• 案例实现步骤：

  ①搜索Tomcat镜像

  ②拉取Tomcat镜像

  ③创建容器

  ④部署项目

  ⑤测试访问

Tomcat部署

一、搜索Tomcat镜像

docker search tomcat
1

二、拉取Tomcat镜像

docker pull tomcat
1

三、查看本地镜像

docker images
1

四、在 /root 目录下创建tomcat目录用于存储tomcat数据信息，进入到tomcat目录中

#创建tomcat目录
mkdir tomcat
#进入到tomcat目录
cd tomcat
1
2
3
4

五、创建容器，设置端口映射、目录映射

docker run -id \
-p 8080:8080 \
--name=tomcat-test \
-v $PWD:/usr/local/tomcat/webapps \
tomcat:latest
1
2
3
4
5

• 参数说明
  • -p 8080:8080：将容器的8080端口映射到主机的8080端口
  • -v $PWD:/usr/local/tomcat/webapps：将主机当前目录挂载到容器的webapps

六、部署项目

#创建test文件夹
mkdir test
#进入到test目录
cd test
#创建并编辑index.html文件
vim index.html
#index.html文件内容
 hellow tomcat docker </h1>
1
2
3
4
5
6
7
8

七、测试访问

#打开浏览器，地址栏输入ip地址:端口号/项目路径
192.168.3.240:8080/test/index.html
1
2

3.Docker应用部署-部署Nginx

• 案例需求：在Docker容器中部署Nginx，并通过外部机器访问Nginx。

• 案例实现步骤：

  ①搜索Tomcat镜像

  ②拉取Tomcat镜像

  ③创建容器

  ④测试访问

Nginx部署

一、搜索Nginx镜像

docker search nginx
1

二、拉取Nginx镜像

docker pull nginx
1

三、查看本地镜像

docker images
1

四、在 /root 目录下创建nginx目录用于存储nginx数据信息，进入到nginx目录中

#创建nginx目录
mkdir nginx
#进入到nginx目录
cd nginx
1
2
3
4

五、在 /root/nginx/目录下创建conf文件夹，进入conf目录创建并编辑nginx.conf文件，粘贴下面内容

#创建conf目录
mkdir conf
#进入到conf目录
cd conf
#创建并编辑nginx.conf文件
vim nginx.conf
1
2
3
4
5
6

nginx.conf文件内容

user  nginx;
worker_processes  1;

error_log  /var/log/nginx/error.log  warn;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

	log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

	access_log  /var/log/nginx/access.log  main;

	sendfile        on;
    #tcp_nopush     on;

	keepalive_timeout  65;

	#gzip  on;

	include /etc/nginx/conf.d/*.conf;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

六、创建容器，设置端口映射、目录映射

docker run -id \
-p 80:80 \
--name=nginx-test \
-v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf \
-v $PWD/logs:/var/log/nginx \
-v $PWD/html:/usr/share/nginx/html \
nginx:latest
1
2
3
4
5
6
7

• 参数说明
  • -p 80:80：将容器的80端口映射到主机的80端口
  • -v $PWD/conf/nginx.conf:/etc/nginx/nginx.conf：将主机当前目录下的/conf/nginx.conf挂载到容器的/etc/nginx/nginx.conf。配置目录
  • -v $PWD/logs:/var/log/nginx：将主机当前目录下的logs目录挂载到容器的/var/log/nginx。日志目录

七、测试访问

#进入到html目录
cd html
#创建并编辑index.html文件
vim index.html
#index.html文件内容
 hellow nginx docker </h1>
1
2
3
4
5
6

浏览器访问IP地址进行测试

4.Docker应用部署-部署Redis

• 案例需求：在Docker容器中部署Redis，并通过外部机器访问Redis。

• 案例实现步骤：

  ①搜索Redis镜像

  ②拉取Redis镜像

  ③创建容器

  ④测试访问

Redis部署

一、搜索Nginx镜像

docker search redis
1

二、拉取Nginx镜像

docker pull redis
1

三、查看本地镜像

docker images
1

三、创建容器，设置端口映射

docker run -id --name=redis-test -p 6379:6479 redis:latest
1

四、连接redis

通过 redis-cli 连接测试使用 redis 服务。

#进入redis-test容器
docker exec -it redis-test /bin/bash
#连接redis
redis-cli
1
2
3
4

五、Dockerfile

1.Dockerfile-镜像原理

操作系统组成部分：

• 进程调度子系统
• 进程通信子系统
• 内存管理子系统
• 设备管理子系统
• 文件管理子系统
• 网络通信子系统
• 作业控制子系统

Linux文件系统由bootfs和rootfs两部分组成

• bootfs：包含bootloader（引导加载程序）和kernel（内核）
• rootfs：root文件系统，包含的就是典型Linux系统中的/dev，/proc，/bin，/etc等标准目录和文件
• 不同的linux发行版，bootfs基本一样，而rootfs不同，如ubuntu，centos等

Docker镜像原理

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

• Docker镜像的本质是什么？

  是一个分层文件系统

• Docker中的一个centos镜像为什么只有200M，而一个centos操作系统的iso文件要几个G？

  Centos的iso镜像文件包含bootfs和rootfs，而Docker的centos镜像复用操作系统的bootfs，只有rootfs和其他镜像层

• Docker中一个tomcat镜像为什么又600MB，而一个tomcat安装包只有70多MB？

  由于docker中镜像是分层的，tomcat虽然只有70多MB，但他需要依赖于父镜像和基础镜像，所有整个对外暴露的tomcat镜像大小600多MB

2.Dockerfile-容器转为镜像

• Docker镜像如何制作？

  一.容器转为镜像

  将容器转为镜像

  docker commit 容器id 新的镜像名称:版本号
  1

  将镜像转为压缩文件（容器没办法传给其他人，只有将容器转为压缩文件才能进行传输）

  docker save -o 压缩文件名称 镜像名称:版本号
  1

  将压缩文件转为镜像

  docker load -i 压缩文件名称
  1

  

  例子

  1.查看容器

  docker ps -a
  1

  

  2.将容器转为镜像

  docker commit 容器id 新的镜像名称:版本号
  1

  docker commit 2b9e6a802d93 tomcat-1:1.0
  1

  

  3.将镜像转为压缩文件

  docker save -o 压缩文件名称 镜像名称:版本号
  1

  docker save -o tomcat.tar tomcat-1:1.0
  1

  

  4.删除镜像

  docker rmi 8a3fa5474e0f
  1

  

  5.将压缩文件转为镜像

  docker load -i 压缩文件名称
  1

  docker load -i tomcat.tar
  1

  

  二.dockerfile

3.Dockerfile-Dockerfile概述及关键字

• 什么是 Dockerfile？

  Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明。

Dockerfile概念

• Dockerfile是一个文本文件
• 包含了一条条的指令
• 每一条指令构建一层，基于基础镜像，最终构建出一个新的镜像
• 对开发人员：可以为开发团队提供一个完全一致的开发环境
• 对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了

4.Dockerfile-案例-部署springboot项目

案例需求：

定义dockerfile，发布springboot项目

实现步骤

1.创建一个springboot项目

2.项目打包

注意事项：项目打包JDK版本要跟后面创建容器所依赖的父镜像JDK版本一致，否者可能导致创建的容器无法运行

3.jar包测试运行

4.下载一个java镜像，用来运行jar包（根据自己的springboot打包所依赖的JDK版本一致）

注意事项：这里的java版本要与打包springboot的JDK版本一致，否者可能导致创建的容器无法运行

docker pull java:8
1

5.创建一个名为 docker-files 的文件夹

mkdir docker-files
1

6.进入到 docker-files 目录下，上传打包好的jar包

7.创建并编辑 springboot-dockerfile文件

vim springroot-dockerfile
1

文件内容

FROM java:8
MAINTAINER xiongjian
ADD springboot-hello-0.0.1-SNAPSHOT.jar springboot-hello.jar
CMD java -jar springboot-hello.jar
1
2
3
4

• 说明
  • 定义父镜像：FROM java:8
  • 定义作者信息：MAINTAINER xiongjian
  • 将jar包添加到容器：ADD springboot-hello-0.0.1-SNAPSHOT.jar springboot-hello.jar
  • 定义容器启动执行的命令：CMD java -jar springboot-hello.jar

8.通过 dockerfile 构建镜像

docker build -f 文件名 -t 镜像名称:镜像标签 .
1

最后的.代表本次执行的上下文路径（上下文路径，是指 docker 在构建镜像，有时候想要使用到本机的文件（比如复制），docker build 命令得知这个路径后，会将路径下的所有内容打包。）

解析：由于 docker 的运行模式是 C/S。我们本机是 C，docker 引擎是 S。实际的构建过程是在 docker 引擎下完成的，所以这个时候无法用到我们本机的文件。这就需要把我们本机的指定目录下的文件一起打包提供给 docker 引擎使用。

如果未说明最后一个参数，那么默认上下文路径就是 Dockerfile 所在的位置。

注意：上下文路径下不要放无用的文件，因为会一起打包发送给 docker 引擎，如果文件过多会造成过程缓慢。

docker build -f springroot-dockerfile -t springboot-hello .
1

8.创建运行容器

docker run -id --name springboot-hello -p 9000:8080 springboot-hello:latest
1

9.外部测试

docker宿主机IP地址:端口号/访问的项目
1

5.Dockerfile-案例-自定义centos

案例需求：

自定义centos7镜像。要求：
1.默认登录路径为/usr
2.可以使用vim

实现步骤

1.在 ~ 目录下创建一个名为 docker-files 文件夹

mkdir docker-files
1

2.进入 docker-files 目录，创建即编辑 contos-dockerfile 文件

vim centos-dockerfile
1

文件内容

FROM centos:7
MAINTAINER xiongjian
RUN yum -y install vim
WORKDIR /usr
CMD /bin/bash
1
2
3
4
5

• 说明
  • 定义父镜像：FROM java:8
  • 定义作者信息：MAINTAINER xiongjian
  • 执行安装vim命令：RUN yum -y install vim
  • 定义默认的工作目录：WORKDIR /usr
  • 定义容器启动执行的命令：CMD /bin/bash

3.构建镜像

docker build -f 文件名 -t 镜像名称:镜像标签 .
1

docker build -f centos-dockerfile -t centos-test:1 .
1

4.创建运行容器（如图所示默认登录路径为/usr）

docker run -it --name=centos-test centos-test:1
1

六、Docker服务编排

服务编排：按照一定的业务规则批量管理容器

微服务架构的应用系统中一般包含若干个微服务，每个微服务一般都会部署多个实例，如果每个微服务都要手动启停维护的工作量会很大。

• 要从Dockerfile build image 或者去dockerhub拉取 image
• 要创建多个container
• 要管理这些container(启动停止删除)

1.Docker Compose-概述

Docker Compose简介

DockerCompose是一个编排多容器分布式部署的工具，提供命今集管理容器化应用的完整开发周期，包括服务构建启动和停止。

Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

Compose 使用的三个步骤：

• 使用 Dockerfile 定义应用程序的环境。
• 使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
• 最后，执行 docker-compose up 命令来启动并运行整个应用程序。

2.Docker Compose-安装使用

Docker Compose 安装

1.安装Compose

Linux 上我们可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：https://github.com/docker/compose/releases

运行以下命令以下载 Docker Compose 的当前稳定版本：

curl -L https://github.com/docker/compose/releases/download/1.8.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose
1

要安装其他版本的 Compose，请替换 1.8.1。

2.设置文件可执行权限

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

3.测试是否安装成功

docker-compose version
1

Docker Compose卸载

二进制包方式安装的，删除二进制文件即可

rm /usr/local/bin/docker-compose
1

3.使用Docker Compose编排nginx+springboot项目

1. 准备nginx镜像和springboot项目镜像(springboot项目镜像可以查看上面的部署springboot案例)

   

2. ~ 目录下创建一个名为 docker-compose 的文件夹并进入到 docker-compose 目录下

   mkdir docker-compose
   cd docker-compose/
   1
   2

   

3. 创建并编辑名为 docker-compose.yml 文件

   vim docker-compose.yml
   1

   

   docker-compose.yml文件内容

   version: '2'
   services:
     nginx:
       image: nginx
       ports:
         - 80:80
       links:
         - springboot-hello
       volumes:
         - ./nginx/conf.d:/etc/nginx/conf.d
     springboot-hello:
       image: springboot-hello
       expose:
         - "8080"
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14

   注意事项：version: ‘2’ 这里的版本要根据 docker-compose 版本所对应，否者后面使用 docker-compose 启动容器会报错

4. 创建 ./nginx/conf.d 目录 ，进入到 ./nginx/conf.d 目录下

   mkdir -p ./nginx/conf.d
   cd nginx/conf.d/
   1
   2

   

5. 创建nginx配置文件并添加内容

   vim nginx.conf
   1

   

   nginx.conf 文件内容

   server {
       listen 80;
       access_log off;
        
       location / {
       	proxy_pass http://springboot-hello:8080;
       }
       
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9

6. 切换到 ~/docker-compose/ 目录下，使用 docker-compose 启动容器

   cd ~/docker-compose/
   docker-compose up
   1
   2

   
   

7. 重新打开一个新的会话查看容器会发现启动了两个容器

   docker ps -a
   1

   

8. 测试访问

   

七、Docker私有仓库

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

1.Docker私有仓库-搭建

1. 拉取私有仓库镜像

   docker pull registry
   1

   

2. 启动私有仓库容器

   docker run -id --name=registry -p 5000:5000 registry
   1

   

3. 访问私有仓库

   打开浏览器，输入地址 http://私有仓库服务器ip:5000/v2/_catalog，看到 {“repositories”:[]} 表示私有仓库搭建成功

   

4. 修改daemon.json配置文件

   vim /etc/docker/daemon.json
   1

   在上述文件中添加一个key，保存退出。此步用于让docker信任私有仓库地址；注意将私有仓库服务器ip修改为自己私有仓库服务器真实ip

   添加的内容

   "insecure-registries": ["私有仓库服务器ip:5000"]
   1

   

5. 重启 docker 服务

   systemctl restart docker
   1

   

6. 私有仓库容器

   重启docker服务导致私有仓库容器停止所以需要启动下私有仓库容器

   docker start registry
   1

   

2.Docker私有仓库-上传镜像

1. 标记镜像为私有仓库的镜像

   docker tag centos:7 私有仓库服务器IP:5000/centos:7
   1

   

2. 上传标记的镜像

   docker push 私有仓库服务器IP:5000/centos:7
   1

   

3. 访问测试私有仓库

   

3.Docker私有仓库-拉取镜像

1. 删除镜像

   docker rmi 192.168.3.240:5000/centos:7
   1

   

2. 拉取镜像

   docker pull 192.168.3.240:5000/centos:7
   1

   

八、Docker相关概念

1.Docker和虚拟机比较

Docker容器虚拟化 与 传统虚拟机比较

容器就是将软件打包成标准化单元，以用于开发、交付和部署。

• 容器镜像是轻量的、可执行的独立软件包，包含软件运行所需的所有内容：代码、运行时环境、系统工具、系统库和设置。
• 容器化软件在任何环境中都能够始终如一地运行。
• 容器赋予了软件独立性，使其免受外在环境差异的影响，从而有助于减少团队间在相同基础设施上运行不同软件时的冲突。

相同

容器和虚拟机具有相似的资源隔离和分配优势

不同

• 容器虚拟化的是操作系统，虚拟机虚拟化的是硬件。
• 传统虚拟机可以运行不同的操作系统，容器只能运行同一类型操作系统

九、Docker参考手册

Docker 资源汇总：https://www.runoob.com/docker/docker-resources.html

Docker命令大全：https://www.runoob.com/docker/docker-command-manual.html

此文档来源于网络,如有侵权，请联系删除！