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

前言

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

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

docker -v

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

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

二、Docker命令

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

• 启动Docker服务

  systemctl start docker
  

• 停止Docker服务

  systemctl stop docker
  

• 重启Docker服务

  systemctl restart docker
  

• 查看Docker服务状态

  systemctl status docker
  

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

  systemctl enable docker
  

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

• 查看镜像

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

  

  各个选项说明：

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

  查看所有镜像的IMAGE ID

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

  

• 搜索镜像

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

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

  

  各个选项说明：

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

• 拉取镜像

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

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

例子

docker pull redis

docker pull redis:5.0

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

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

• 删除镜像

方法一（根据IMAGE ID删除）

docker rmi IMAGE ID

例子

docker rmi 7614ae9453d1

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

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

方法三（删除全部）

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

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

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

• 查看容器

语法：

docker ps [OPTIONS]

OPTIONS说明：

参数	作用
-a	显示所有的容器，包括未运行的
-f	根据条件过滤显示的内容
–format	指定返回值的模板文件
-l	显示最近创建的容器
-n	列出最近创建的n个容器
–no-trunc	不截断输出
-q	静默模式，只显示容器编号
-s	显示总的文件大小

实例

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

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

输出详情介绍：

名称	含义
CONTAINER ID	容器 ID
IMAGE	使用的镜像
COMMAND	启动容器时运行的命令
CREATED	容器的创建时间
STATUS	容器状态 （状态有7种：created（已创建）、restarting（重启中）、running（运行中）、removing（迁移中）、paused（暂停）、exited（停止）、dead（死亡））
PORTS	容器的端口信息和使用的连接类型（tcp\udp）
NAMES	自动分配的容器名称

• 创建容器

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

语法：

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

OPTIONS说明：

参数	作用
-a stdin	指定标准输入输出内容类型，可选 STDIN/STDOUT/STDERR 三项
-d	后台运行容器，并返回容器ID
-i	以交互模式运行容器，通常与 -t 同时使用
-P	随机端口映射，容器内部端口随机映射到主机的端口
-p	指定端口映射，格式为：主机(宿主)端口:容器端口
-t	为容器重新分配一个伪输入终端，通常与 -i 同时使用
–name=“nginx-lb”	为容器指定一个名称
–dns 8.8.8.8	指定容器使用的DNS服务器，默认和宿主一致
–dns-search example.com	指定容器DNS搜索域名，默认和宿主一致
-h “mars”	指定容器的hostname
-e username=“ritchie”	设置环境变量
–env-file=[]	从指定文件读入环境变量
–cpuset=“0-2” or --cpuset=“0,1,2”	绑定容器到指定CPU运行
-m	设置容器使用内存最大值
–net=“bridge”	指定容器的网络连接类型，支持 bridge/host/none/container: 四种类型
–link=[]	添加链接到另一个容器
–expose=[]	开放一个端口或一组端口
–volume , -v	绑定一个卷

实例

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

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

说明：

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

• 进入容器

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

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

docker attach [OPTIONS] CONTAINER

实例

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

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

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

OPTIONS说明：

参数	作用
-d	分离模式: 在后台运行
-i	即使没有附加也保持STDIN 打开
-t	分配一个伪终端

实例

docker exec -it mycentos1 /bin/bash

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

• 启动容器

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

• 停止容器

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

• 重启容器

docker restart 容器名|容器 ID

• 删除容器

docker rm 容器名|容器 ID

• 查看容器信息

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

语法：

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

OPTIONS说明：

参数	作用
-f	指定返回值的模板文件
-s	显示总的文件大小
–type	为指定类型返回JSON

三、Docker容器的数据卷

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

思考：

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

数据卷

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

数据卷概念

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

数据卷作用

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

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

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

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

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

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

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

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

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

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

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

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
   

   
   

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
   

   
   

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

四、Docker应用部署

1.Docker应用部署-部署MySQL

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

• 案例实现步骤：

  ①搜索MySQL镜像

  ②拉取MySQL镜像

  ③创建容器

  ④操作容器中的MySQL

MySQL部署

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

一、搜索MySQL镜像

docker search mysql

二、拉取MySQL镜像

docker pull mysql:latest

三、查看本地镜像

docker images

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

#创建mysql目录
mkdir mysql
#进入到mysql目录
cd mysql

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

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

• 参数说明
  • -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

七、登录MySQL

mysql -uroot -p123456

外部访问Doker中的MySQL容器

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

2.使用DataGrip 连接

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

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

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

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

   select  User,authentication_string,Host from user;
   

   

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

2.Docker应用部署-部署Tomcat

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

• 案例实现步骤：

  ①搜索Tomcat镜像

  ②拉取Tomcat镜像

  ③创建容器

  ④部署项目

  ⑤测试访问

Tomcat部署

一、搜索Tomcat镜像

docker search tomcat

二、拉取Tomcat镜像

docker pull tomcat

三、查看本地镜像

docker images

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

#创建tomcat目录
mkdir tomcat
#进入到tomcat目录
cd tomcat

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

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

• 参数说明
  • -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文件内容
<h1> hellow tomcat docker </h1>

七、测试访问

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

3.Docker应用部署-部署Nginx

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

• 案例实现步骤：

  ①搜索Tomcat镜像

  ②拉取Tomcat镜像

  ③创建容器

  ④测试访问

Nginx部署

一、搜索Nginx镜像

docker search nginx

二、拉取Nginx镜像

docker pull nginx

三、查看本地镜像

docker images

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

#创建nginx目录
mkdir nginx
#进入到nginx目录
cd nginx

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

#创建conf目录
mkdir conf
#进入到conf目录
cd conf
#创建并编辑nginx.conf文件
vim nginx.conf

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;
}

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

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

• 参数说明
  • -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文件内容
<h1> hellow nginx docker </h1>

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

4.Docker应用部署-部署Redis

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

• 案例实现步骤：

  ①搜索Redis镜像

  ②拉取Redis镜像

  ③创建容器

  ④测试访问

Redis部署

一、搜索Nginx镜像

docker search redis

二、拉取Nginx镜像

docker pull redis

三、查看本地镜像

docker images

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

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

四、连接redis

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

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

五、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 新的镜像名称:版本号
  

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

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

  将压缩文件转为镜像

  docker load -i 压缩文件名称
  

  

  例子

  1.查看容器

  docker ps -a
  

  

  2.将容器转为镜像

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

  docker commit 2b9e6a802d93 tomcat-1:1.0
  

  

  3.将镜像转为压缩文件

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

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

  

  4.删除镜像

  docker rmi 8a3fa5474e0f
  

  

  5.将压缩文件转为镜像

  docker load -i 压缩文件名称
  

  docker load -i tomcat.tar
  

  

  二.dockerfile

3.Dockerfile-Dockerfile概述及关键字

• 什么是 Dockerfile？

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

Dockerfile概念

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

Dockerfile 指令	说明
FROM	指定基础镜像，用于后续的指令构建。
MAINTAINER	指定Dockerfile的作者/维护者。（已弃用，推荐使用LABEL指令）
LABEL	添加镜像的元数据，使用键值对的形式。
RUN	在构建过程中在镜像中执行命令。
CMD	指定容器创建时的默认命令。（可以被覆盖）
ENTRYPOINT	设置容器创建时的主要命令。（不可被覆盖）
EXPOSE	声明容器运行时监听的特定网络端口。
ENV	在容器内部设置环境变量。
ADD	将文件、目录或远程URL复制到镜像中。
COPY	将文件或目录复制到镜像中。
VOLUME	为容器创建挂载点或声明卷。
WORKDIR	设置后续指令的工作目录。
USER	指定后续指令的用户上下文。
ARG	定义在构建过程中传递给构建器的变量，可使用 “docker build” 命令设置。
ONBUILD	当该镜像被用作另一个构建过程的基础时，添加触发器。
STOPSIGNAL	设置发送给容器以退出的系统调用信号。
HEALTHCHECK	定义周期性检查容器健康状态的命令。
SHELL	覆盖Docker中默认的shell，用于RUN、CMD和ENTRYPOINT指令。

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

案例需求：

定义dockerfile，发布springboot项目

实现步骤

1.创建一个springboot项目

2.项目打包

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

3.jar包测试运行

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

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

docker pull java:8

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

mkdir docker-files

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

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

vim springroot-dockerfile

文件内容

FROM java:8
MAINTAINER xiongjian
ADD springboot-hello-0.0.1-SNAPSHOT.jar springboot-hello.jar
CMD java -jar springboot-hello.jar

• 说明
  • 定义父镜像：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 镜像名称:镜像标签 .

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

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

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

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

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

8.创建运行容器

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

9.外部测试

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

5.Dockerfile-案例-自定义centos

案例需求：

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

实现步骤

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

mkdir docker-files

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

vim centos-dockerfile

文件内容

FROM centos:7
MAINTAINER xiongjian
RUN yum -y install vim
WORKDIR /usr
CMD /bin/bash

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

3.构建镜像

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

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

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

docker run -it --name=centos-test centos-test: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

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

2.设置文件可执行权限

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

3.测试是否安装成功

docker-compose version

Docker Compose卸载

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

rm /usr/local/bin/docker-compose

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

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

   

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

   mkdir docker-compose
   cd docker-compose/
   

   

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

   vim docker-compose.yml
   

   

   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"
   

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

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

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

   

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

   vim nginx.conf
   

   

   nginx.conf 文件内容

   server {
       listen 80;
       access_log off;
        
       location / {
       	proxy_pass http://springboot-hello:8080;
       }
       
   }
   

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

   cd ~/docker-compose/
   docker-compose up
   

   
   

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

   docker ps -a
   

   

8. 测试访问

   

七、Docker私有仓库

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

1.Docker私有仓库-搭建

1. 拉取私有仓库镜像

   docker pull registry
   

   

2. 启动私有仓库容器

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

   

3. 访问私有仓库

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

   

4. 修改daemon.json配置文件

   vim /etc/docker/daemon.json
   

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

   添加的内容

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

   

5. 重启 docker 服务

   systemctl restart docker
   

   

6. 私有仓库容器

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

   docker start registry
   

   

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

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

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

   

2. 上传标记的镜像

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

   

3. 访问测试私有仓库

   

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

1. 删除镜像

   docker rmi 192.168.3.240:5000/centos:7
   

   

2. 拉取镜像

   docker pull 192.168.3.240:5000/centos:7
   

   

八、Docker相关概念

1.Docker和虚拟机比较

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

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

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

相同

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

不同

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

特性	容器	虚拟机
启动	秒级	分钟级
硬盘使用	一般为MB	一般为GB
性能	接近原生	弱于
系统支持量	单机支持上千个容器	一般几十个

九、Docker参考手册

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

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

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