【技术分享】走进Docker的世界：从基础到实战全面解析(Docker全流程)

1.简介与概述

1. Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。
   Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。
2. Docker的主要目标是‘build ，ship and run any app，anywhere’，也就是说通过对应用程序组件的封装，分发，部署，运行等生命周期的管理。使用户的app（可以是一个web应用程序或者数据库应用等）及其运行环境能够做到‘一次封装，到处运行’。
3. Linux容器技术的出现解决了这个问题。而docker就是基于他的基础上发展过来的。将应用运行到docker容器上面，而docker容器在任何操作系统上都是一致的，这就是实现跨平台跨服务器。只需要一次配置好环境，换到别的机子上就可以一键部署好，大大简化了操作。
   容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。
4. Docker 从 17.03 版本之后分为 CE（Community Edition: 社区版） 和 EE（Enterprise Edition: 企业版），我们用社区版就可以了。

Docker实际上就是一个虚拟化轻量级linux服务器，可以解决我们在开发环境中运行配置问题。

1.1为什么需要使用docker

Docker：虚拟化容器技术
Docker主要解决我们开发环境配置迁移的问题。

1. 我们现在开发了一个javaweb项目，需要依赖很多环境配置 比如：Tomcat、JDK环境、Nginx、Redis环境等。
2. 本地需要安装这些环境Tomcat、JDK环境、Nginx、Redis环境等，在打war包给运维部署在linux服务器，运维人员也需要在linux服务器上安装Tomcat、JDK环境、Nginx、Redis环境。
3. 但是有时候可能会发生这些问题：我在本地运行环境没有问题，但是打包到Linux服务器运行总是遇到很多错误，大多数由于一些版本冲突影响。
4. 所以在这时候我们就可以使用docker部署和安装软件就非常方便，直接将该springboot项目制作成一个镜像文件，镜像文件中包含jdk版本 tomcat版本信息 直接部署linux即可，减少依赖冲突概率。

看看linux安装mysql

Mysql很容易发生版本冲突的问题。
在对比docker安装mysql

docker pull mysql:5.7 
docker create --name mysql3308 -e MYSQL_ROOT_PASSWORD=root -p 3308:3306 mysql:5.7

Docker最终解决了运行环境配置中的问题。----镜像文件底层封装好了

1.2 使用docker的好处

1. 简化配置 安装创建非常的方便
2. 代码流水线（Code Pipeline）管理 传统项目部署可能需要经过很多环节，容易产生版本的依赖冲突问题，Docker给应用提供了一个从开发到上线均一致的环境，让代码的流水线变得简单不少
3. Devops 开发与运维一体化减少沟通的成本 （docker或者是k8s实现）
4. 虚拟技术 快速部署
5. 弹性扩容

1.3 应用场景

1. Web 应用的自动化打包和发布。
2. 自动化测试和持续集成、发布。
3. 在服务型环境中部署和调整数据库或其他的后台应用。
4. 从头编译或者扩展现有的 OpenShift 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

1.4 容器与虚拟机区别

什么是虚拟机：在一台物理机器上，利用虚拟化技术，虚拟出来多个操作系统，每个操作系统之间是隔离的。

从下到上理解上图：
最下面的一层就是物理机，可以是服务器，设置是一台个人电脑；

电脑上需要安装操作系统，比如我们安装了win10的操作系统；
再往上就是虚拟机软件了，比如我们常用的VirtualBox、VMWare，它们的作用是模拟计算机硬件；

继续向上，就是虚拟机模拟出来的操作系统了；

在虚拟的操作系统中，安装所需的软件、组件等。比如我们需要在虚拟操作系统中安装JDK、Tomcat等；

最后就是具体的应用了，例如部署到Tomcat中。

Docker ：Docker是开源的应用容器引擎

依然从下往上看：
最下面两层，概念同上。
往上，可以看做Docker容器的管理器。
依赖和应用都被打包成了Docker镜像。例如，JDK、Tomcat、应用都被打包在了一起，运行在Docker容器里，容器和容器间是隔离的。

1.4 Docker和虚拟机的区别

1. 从两者的架构图上看，虚拟机是在硬件级别进行虚拟化，模拟硬件搭建操作系统；而Docker是在操作系统的层面虚拟化，复用操作系统，运行Docker容器。
2. Docker的速度很快，秒级，而虚拟机的速度通常要按分钟计算。
3. Docker所用的资源更少，性能更高。同样一个物理机器，Docker运行的镜像数量远多于虚拟机的数量。
4. 虚拟机实现了操作系统之间的隔离，Docker是进程之间的隔离，虚拟机隔离级别更高、安全性方面也更强。
5. 虚拟机和Docker各有优势，不存在谁替代掉谁的问题，很多企业都采用物理机上做虚拟机，虚拟机中跑Docker的方式。

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

1.5 Docker官网

查询虚拟机的ip地址1
查询虚拟机的ip地址2

2. Docker快速入门

2.1 Docker安装

centos8如何安装yum源
先卸载旧版本(如果安装过旧版本的话)

yum remove docker docker-common docker-selinux docker-engine

进入目录 cd /etc/yum.repos.d //进入/etc/yum.repos.d目录
查看并删除/etc/yum.repos.d目录下所有的配置文件 ll //查看当前目录的所有文件
rm -rf ./* //删除当前的所有文件
下载centos8的镜像源 wget -O /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-8.repo
ls //查看文件
yum -y clean all //清除所有文件
yum -y makecache //建立缓存
yum repolist //查看yum仓库信息

安装docker准备工作
Docker 要求 CentOS7 系统的内核版本在 3.10以上 ，查看本页面的前提条件来验证你的CentOS 版本是否支持 Docker 。
1、通过 uname -r 命令查看你当前的内核版本

uname -r

使用 root 权限登录 Centos。确保 yum 包更新到最新。

yum -y update

该过程大概需要维持10分钟左右
安装需要的软件包， yum-util 提供yum-config-manager功能，另外两个是devicemapper驱动依赖的

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

设置yum源

yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

可以查看所有仓库中所有docker版本，并选择特定版本安装

yum list docker-ce --showduplicates | sort -r

安装docker

sudo yum install -y docker-ce     #由于repo中默认只开启stable仓库，故这里安装的是最新稳定版18.03.1

可以使用：sudo yum install -y docker-ce --allowerasing

启动并加入开机启动

systemctl start docker
systemctl enable docker

查看进程

ps aux | grep 'docker'

验证安装是否成功(有client和service两部分表示docker安装启动都成功了)

docker version

2.2 Docker核心名词

镜像:简单理解为就是一个安装包，里面包含容器所需要运行的的基础文件和配置信息，比如：redis镜像、mysql镜像等。
镜像的来源方式：

1. 自己做镜像 比如（自己开发微服务项目）
2. 拉取别人制作好的镜像， 例如 nginx、mysql、redis等。

容器: 容器就是镜像运行的实例，容器状态分为：初创建、运行、停止、暂停、
删除， 一个镜像可以创建多个不同的容器。

每个镜像文件都有自己独立ip信息—轻量级的linux服务器 虚拟化

比如：镜像就是类 容器就是实例对象
仓库: 仓库可以简单理解为，专门存储镜像文件仓库， 类似于 谷歌手机市场，统一在
谷歌手机市场下载开发者的安装包。
Docker 公开仓库地址 Docker hub

Docker官方仓库 ----访问比较慢

1. 需要制作镜像文件（springboot项目）------类似于开发者开发安装应用程序打包

2. 需要将我们制作好的镜像文件提交到docker仓库中-----开发者将自己的app应用程序发布安卓手机助手中。

3. 本地需要拉去我们docker仓库中下载镜像文件，在交给我们容器运行—用户从app市场中下载安装包运行。

4. 在需要制作镜像文件，将该镜像文件发布到docker仓库
   docker仓库 dockerhub ----谷歌安卓手机市场 国内加速镜像
   阿里云、网易、科大（）----360、小米、华为。

5. 从docker仓库下载镜像文件-----用户从手机市场中，下载软件。

6. docker运行镜像文件----容器—独立ip访问信息-----端口号码映射

2.3 Docker镜像

Docker下载镜像原理
Docker pull 从远程docker 官方仓库下载 镜像，到本地，在使用容器运行该镜像。
注意的是：docker官方镜像仓库地址部署在国外，下载镜像可能比较慢，建议配置国内加速镜像

Docker加载镜像配置
https://hub.docker.com/search?q=redis&type=image —在国外访问可能比较慢
国内从 DockerHub 拉取镜像有时会遇到困难，此时可以配置镜像加速器。Docker 官方和国内很多云服务商都提供了国内加速器服务，例如：

科大镜像
网易
阿里云：https://<你的ID>.mirror.aliyuncs.com
七牛云加速器
当配置某一个加速器地址之后，若发现拉取不到镜像，请切换到另一个加速器地址。国内各大云服务商均提供了 Docker 镜像加速服务，建议根据运行 Docker 的云平台选择对应的镜像加速服务。

2.4阿里云加速镜像配置

我的加速镜像：https://<你的ID>.mirror.aliyuncs.com

阿里云镜像获取地址：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors，登陆后，左侧菜单选中镜像加速器就可以看到你的专属地址了：

配置镜像加速器
针对Docker客户端版本大于 1.10.0 的用户
您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器
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 info

2.5 Docker常用命令

公共的 Docker 镜像仓库和社区

操作描述	命令示例
查看帮助信息	docker --help
获取 Docker 版本信息	docker -version
列出所有 Docker 镜像	docker images docker images -a
只显示镜像的 ID	docker images -q
显示镜像的摘要信息	docker images --digests
显示完整镜像信息	docker images --no-trunc
删除镜像文件	docker rmi tomcat:8 docker rmi IMAGE ID
强制删除 Docker 镜像（包括正在运行的容器）	docker rmi -f tomcat:8
在 Docker Hub 上搜索公共可用的镜像	docker search
搜索 Docker Hub 上与“nginx”相关的镜像	docker search nginx
列出点赞数超过30及以上的mysql相关镜像	docker search -s 30 mysql
从 Docker 镜像仓库中拉取一个镜像到本地系统	docker pull
下载最新版本的nginx	docker pull nginx:latest
下载tomcat 8（若不指定版本则下载最新版本的镜像）	docker pull tomcat:8

latest -----tag 最新版本的镜像文件
删除镜像文件如果报错：Error response from daemon: conflict: unable to remove repository reference "centos:latest" (must force) - container fcf2ee80481e is using its referenced image 5d0da3dc9764
是因为这个镜像已经作为容器启动运行过，需要先删除容器，再删除镜像

docker images 各列的含义

项	描述
REPOSITORY	存储库名称
Tag	镜像的标签；不写版本号，默认下载最新（latest）镜像
IMAGE ID	镜像ID
CREATED	创建时间
SIZE	大小

2.6容器管理

查看容器信息

Docker  ps  

获取到容器id
查询 Docker 容器的详细信息时：docker inspect [CONTAINER ID]

运行容器
docker run
docker run -i（保持容器一直运行）
-t（给容器一个伪终端）
-d(后台运行，不直接进入容器)
--name=tomcat9.2（给启动容器起名字）
-p 8080:8080(宿主:docker容器)
tomcat:9.2(启动的容器) 【参数】(加入容器初始化命令)
#通过 -it 启动的容器有两个特点 一创建就进入容器 exit退出容器 容器就会停止运行 —交互式容器
#通过 -id 创建的容器 docker exec -it tomcat9.2（–name起的名称）进入容器 exit退出容器 容器不会停止运行 —守护式容器

操作描述	命令示例
查看正在运行的容器	docker ps
查看运行和已停止的容器	docker ps -a
关闭容器	docker stop tomcat8
启动容器	docker start tomcat8
删除容器	docker rm tomcat8
查看容器信息	docker inspect tomcat8
进入容器	docker exec [参数] tomcat8

注意：在使用docker exec命令时，通常会加上 -it 参数来获得交互式 shell，例如：docker exec -it tomcat8 /bin/bash。

docker run 运行原理
docker run mayikt (运行一个不存在的容器会报错)

简单描述：
首先会先从本地获取获取mayikt镜像文件，如果本地没有该镜像文件则会去阿里云仓库查找该镜像文件，如果阿里云仓库也没有该镜像文件，则会报错找不到镜像文件。获取到镜像文件之后直接运行。
详细描述：

1. docker在本机缓存中 mayikt镜像文件，如果本地存在该镜像文件，则以该镜像文件作为模板在容器中运行。
2. 如果本地缓存中，没有mayikt镜像文件 则会从dockerhub 或者加速镜像中查找，如果查找不到的话，则返回错误找不到该镜像。
3. 如果能够查找到该镜像，则以该镜像作为模板运行。
   

每个容器都有自己独立的网络 ip信息 运行成功 就是一个轻量级linux操作系统

启动容器docker start 容器id

停止容器docker stop 容器id

删除容器docker rm 容器id

进入容器中

# 首先使用下面的命令，查看容器ID（CONTAINER ID）： 
docker ps -a
# 然后用下面的命令进入容器，就可以使用bash命令浏览容器里的文件：
docker exec -it [CONTAINER ID] bash
# 有的镜像没有bash命令，可以用对应的shell，比如sh
docker exec -it [CONTAINER ID] sh

2.7 Docker 镜像原理

镜像是什么
基于docker安装tomcat服务器 是否需要配置jdk环境变量呢？
docker安装tomcat:8 --jdk8 配置环境变量
docker安装tomcat:9 --jdk9 配置环境变量

如何封装配置环境依赖的呢？

Dockerfile—文件

Tomcat 100mb 依赖于我们JDK 200mb Linux服务器centos 200mb
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境的开发软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。

镜像文件的组成通过 Union fs
运行我们tomcat镜像文件

tomcat镜像文件

1. 依赖于我们JDK
2. Linux服务器

为什么运行tomcat镜像文件，不需要配置jdk环境变量。

1. tomcat镜像文件包含jdk依赖镜像 tomcat8-----jdk8镜像文件
2. 底层dockerfile -----描述配置jdk环境

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

Docker镜像底层实际上是有多个不同的联合文件系统组成的

最底层：bootfs，并使用宿主机的bootfs-复用
第二层：root文件系统rootfs,称为base image
Union fs
然后再往上可以叠加其他的镜像文件
统一文件系统（Union File System）技术能够将不同的层整合成一个文件系统，为这些层提供了一个统一的视角，隐藏多层的存在，我们看来只是存在一个文件系统。

所以当我们安装的tomcat镜像大小是600多MB 是因为里面还包含了jdk和centos的镜像
而centos镜像复用了宿主机的bootfs 下载的只有rootfs 所以小很多

所以tomcat>jdk（父镜像）->centos> 所以整个向外暴露就是600MB
镜像只读 当从一个镜像启动容器时， 所以docker会在镜像上面加载一个可读可写的文件系统作为容器运行。

https://hub.docker.com/_/tomcat

2.8 Docker Commit

主要作用：根据当前容器制作为镜像文件

流程：

1. 从docker hub中下载一个tomcat8镜像文件；或者查看容器中有没有停止运行的tomcat8镜像文件
2. 运行tomcat8镜像文件 在tomcatwebapps 目录中新增 mayikt文件夹 index.html
3. 将当前容器内容根据模板制作为镜像文件

docker commit提交容器副本使之成为一个新的镜像
命令：docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

1. 安装一个tomcat8
   docker run -p 8081:8080 tomcat:8
   或者查看容器中有没有停止运行的tomcat8镜像文件
   docker ps -a
docker start [CONTAINER ID]
   

2. 进入容器
   docker exec -it [CONTAINER ID] bash
cd webapps 进入webapps目录中
   mkdir zhaoli 创建一个zhaoli文件夹(项目中)
   cd zhaoli 进入zhaoli目录中
   echo "zhaoli" >>index.html 创建一个index.html 里面的内容为zhaoli
   
   访问
   

3. 根据当前容器制作为镜像文件
   docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]

• 根据当前容器作为模板制作为镜像文件
  docker commit -m="zhaoli tomcat" -a="zhaoli" 3a06b4c779a8 zhaoli-tomcat:1.0
• 在以当前自己制作的镜像文件运行
  docker run -p 8088:8080 zhaoli-tomcat:1.0
  
  
  

2.9 Docker数据卷

基本的概念
数据卷就是宿主机上的一个文件或目录
当容器目录和数据卷（宿主机）目录绑定，双方修改会立即同步操作
一个数据卷可以被多个容器同时挂载
数据卷作用：容器数据的持久化 外部机器和容器间接通信 容器之间数据交换
使用 -v命令。

数据卷添加的方式
容器内与宿主机实现数据的共享
数据卷–添加两种方式

1. 直接命令形式添加 docker run -it -v 宿主机绝对路径目录:容器内目录 镜像文件名称
2. Dockerfile方式添加

安装Nginx实现负载均衡
挂载nginx html文件
https://hub.docker.com/search?q=nginx&type=image

1. 创建挂载目录
   mkdir -p /data/nginx/{conf,conf.d,html,logs}
   

2. 启动docker容器
   docker run --name nginx81 -d -p 81:80 -v /data/nginx/html:/usr/share/nginx/html nginx
-v /data/nginx/html: linux虚拟机目录
/usr/share/nginx/html 容器中html目录
   
   上传一个 html 放入到 /data/nginx/html

nginx .conf文件和日志文件
docker run --name nginx81 -d -p 81:80 -v /data/nginx/html:/usr/share/nginx/html \
-v /data/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
-v /data/nginx/logs:/var/log/nginx nginx

\反斜杠 表示换行
/usr/share/nginx/html
/usr/share/nginx/conf
/usr/share/nginx/log

2.10 Docker实战部署软件

2.10.1 安装Tomcat服务器

docker run -p 8081:8080 tomcat:8
运行基于 Tomcat 8 的 Docker 容器并将容器的 8080 端口映射到主机的 8081 端口
-p 8081 :8080 容器外部（linux虚拟机访问端口8081）:8080（容器端口号）

docker run -p 8081:8080 -d tomcat:8
在后台以守护模式（detached mode）运行容器。这样容器会在后台运行，不会占用您的终端 —每次运行都会创建一个新的容器
-d 后台启动
前台启动与后台启动的区别
前台启动会打印启动日志信息
后台启动不会打印启动日志信息
docker run --name mayikt-tomcat -p 8081:8080 -d tomcat:8
是启动一个名为 mayikt-tomcat 的容器，并将容器的 8080 端口映射到主机的 8081 端口以后台以守护模式（detached mode）运行容器
8081（容器外部或者linux虚拟机访问的端口号 宿主机）
8080 容器内部的端口号
–name: 指定容器名称
-p:指定容器端口号
-d:指定容器后台运行

docker exec -it [CONTAINER ID] bash
将能够在一个正在运行的容器（ID或名称为?）内部启动一个交互式的 Bash 终端

2.10.2 安装Nginx实现静态服务

docker run --name nginx-mayikt -p 8080:80 nginx 默认前台启动
docker run --name nginx-mayikt -p 8080:80 -d nginx 后台启动方式
docker run 运行容器
--name nginx-test容器名称。
-p 8080:80 端口进行映射，将本地 8080 端口映射到容器内部的 80 端口。
-d nginx 设置容器在在后台一直运行。

docker ps — 正在运行的容器
docker ps -a 显示所有的容器 包括为运行的容器
docker ps 容器id

前台与后台启动区别：

• 前台启动：会展示容器启动的日志信息-----
• 后台启动：不会展示启动日志信息

8080:80 8080 虚拟机本地端口 —浏览器访问 80 容器内部端口

2.10.3 安装MySQL5.7

1. 查询mysql版本
   docker search mysql
2. 下载MySQL5.7版本
   docker pull mysql:5.7 (这里选择的是第一个mysql镜像， :5.7选择的5.7版本)
3. 等待下载完成、创建MySQL容器
   docker create --name mysql3308 -e MYSQL_ROOT_PASSWORD=root -p 3308:3306 mysql:5.7
   创建容器名称为mysql3308，密码为root
4. 启动容器
   docker start mysql3308
5. 进入到容器
   docker exec -it mysql3308 bash
6. mysql连接
   mysql -uroot –p
   
   

2.10.4 Docker运行底层原理

1. 首先启动docker systemctl start docker
2. Docker是一个CS架构的系统，docker守护进程运行在主机上，让后通过socket连接
   从客户端访问，守护进程从客户端接收命令管理运行在主机上的容器。
   ps aux | grep 'docker'

2.10.5 数据卷volumes-from

容器间传递共享数据volumes-from

2.10.6 启动容器报错了如何解决？

先改为前台启动如果没有问题的情况下，在修改为后台启动。

3.DockerFile 解析

一个镜像文件到底是如何创建？

1. dockerfile 描述出镜像文件需要的一些依赖配置和环境变量 执行命令

2. 将我们dockerfile 文件打包成一个镜像文件

3. 直接使用我们的容器运行到该镜像文件。

4. 需要手动编写一个dockerfile文件

5. 将该dockerfile docker build 自定义成一个镜像文件

6. docker run 运行容器

3.1 Centos镜像文件

docker run -it centos

https://github.com/CentOS/sig-cloud-instance-images/blob/b2d195220e1c5b181427c3172829c23ab9cd27eb/docker/Dockerfile

3.2 DockerFile编写规范

A.描述注释
B.指令必须要大写，后面至少需要带至少一个参数;
C.指令是按照从上到下，顺序执行；

3.3 DockerFile指令

1. FROM 指定父镜像: 基于哪个镜像image构建 指定基础镜像，必须为第一个命令
2. MAINTAINER :维护者
3. RUN: 容器创建的时候执行一段命令 构建镜像时执行的命令
4. ADD: 将本地文件添加到容器中，tar类型文件会自动解压(网络压缩资源不会被解压)，可以访问网络资源，类似wget
5. COPY:功能类似ADD，但是是不会自动解压文件，也不能访问网络资源
6. CMD:构建容器后调用，也就是在容器启动时才进行调用。 .sh执行文件
7. ENV: 设置环境变量
8. EXPOSE: 指定于外界交互的端口
9. VOLUME 用于指定持久化目录
10. WORKDIR 设置进入容器时的路径 默认访问的目录

Tomcat-----jdk环境

Tomcat docker File：
https://github.com/docker-library/tomcat/blob/385e8403a38fab7097d4c3fed2484caba7dfd099/8.5/jdk8/openjdk-slim-buster/Dockerfile

https://github.com/docker-library/redis/blob/231905d0841f52ee4f3a5b8b42d62cd6d14a1a93/6.2/Dock

进入tomcat 容器----/data
redis容器----/data
有的容器是---- /

3.4 DockerFile案例

Base镜像(scratch) docker hub中的镜像都是通过base镜像中安装和配置需要的软件构建的。

3.5 构建自己centos镜像

docker run -it centos 运行centos容器并进入它的根目录

1. 需要自己制作一个dockerfile文件
2. 继承docker hub中的centos
3. 在docker hubcentos 上加入以下两个功能

• 进入容器中 默认访问目录/usr
• 实现支持vim插件 yum -y install vim

需要将该dockerfile文件打包成一个镜像文件 交给我们容器执行

https://github.com/CentOS/sig-cloud-instance-images/blob/b2d195220e1c5b181427c3172829c23ab9cd27eb/docker/Dockerfile

定制CentOS镜像

# 继承 docker hub 中的 centos 镜像文件
FROM  centos
# 自己定制的镜像文件作者
MAINTAINER zhaoli
# 配置环境变量 MYPATH 
ENV  MYPATH /usr
# 进入到容器中默认访问的目录 /user
WORKDIR $MYPATH
# 安装下载 vim
RUN yum -y install vim
# 外部访问端口号 80
EXPOSE 80
# 启动成功容器后 自动进入到容器中
CMD /bin/bash

Dockerfile→使用docker 将该Dockerfile实现打包成镜像文件→容器运行该镜像文件。

docker build—将该Dockerfile实现打包成镜像文件

将该dockerfile文件上传到linux服务器中

使用docker build -f Dockerfile -t mycs:1 .
Dockerfile ------配置文件
mycs-—打包镜像文件名称
1 tag 版本号码
记得后面不要少了空格和点
运行并进入容器
docker run -it mycs:1
未定制之前


定制之后

3.6 将springboot项目打包部署

mvn clean package maven 打包jar包 具体请见十二9.4 打包发布
将打包好的项目发送给 linux

制作dockerfile文件

# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER com.zhaoli
# VOLUME 指定了临时文件目录为/tmp。
# 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为zhaoli.jar
ADD MyJavaSpringBoot-helloworld-1.0-SNAPSHOT.jar zhaoli.jar
# 运行jar包
RUN bash -c 'touch /mayikt.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/zhaoli.jar"]
#暴露8080端口
EXPOSE 8080

打包成镜像文件
docker build -f Dockerfile -t mayikt-member:1 .

启动容器
docker run -p 8070:8080 mayikt-member:1

访问测试

过程展示

4.Docker Compose

4.1为什么需要使用Docker Compose

Docker Compose 容器编排技术

现在我们有一个springboot项目，需要依赖Redis、mysql5.7、nginx。
如果使用docker原生部署的话，则需要安装Redis、mysql5、nginx容器，在才可以启动我们springboot项目，这样的话部署项目的流程非常复杂，所以需要引入我们的Docker compose实现容器编排技术。

基本的概念
Docker-Compose项目是Docker官方的开源项目，负责实现对Docker容器集群的快速编排。
Docker-Compose将所管理的容器分为三层，分别是工程（project），服务（service）以及容器（container）。
开发一个springboot项目—大工程

1. 依赖mysql
2. 依赖redis
3. 依赖zk等。

需要在docker-compose.yml 配置项目工程依赖环境配置

Docker-Compose运行目录下的所有文件（docker-compose.yml，extends文件或环境变量文件等）组成一个工程，若无特殊指定工程名即为当前目录名。一个工程当中可包含多个服务，每个服务中定义了容器运行的镜像，参数，依赖。一个服务当中可包括多个容器实例，Docker-Compose并没有解决负载均衡的问题，因此需要借助其它工具实现服务发现及负载均衡。

Docker-Compose的工程配置文件默认为docker-compose.yml，可通过环境变量COMPOSE_FILE或-f参数自定义配置文件，其定义了多个有依赖关系的服务及每个服务运行的容器。

Compose 中有两个重要的概念：
服务 (service) ：一个应用的容器，实际上可以包括若干运行相同镜像的容器实例。
项目 (project) ：由一组关联的应用容器组成的一个完整业务单元，在 docker-compose.yml 文件中定义。
一个项目可以由多个服务（容器）关联而成，Compose 面向项目进行管理，通过子命令对项目中的一组容器进行便捷地生命周期管理。

Compose 项目由 Python 编写，实现上调用了 Docker 服务提供的 API 来对容器进行管理。因此，只要所操作的平台支持 Docker API，就可以在其上利用 Compose 来进行编排管理。

Docker-Compose分成三层

1. 项目层 springboot项目依赖于我们的mysql redis、nginx等 一个项目是由多个容器组成的。
2. 服务层 运行一个镜像的实例 —

4.2 Compose环境安装（离线安装）

1. 访问docker compose github 官网
   

2. docker-compose-Linux-x86_64 上传到服务器/usr中，然后执行如下命令将其移动到/usr/local/bin/目录中 并且更名为docker-compose
mv docker-compose-Linux-x86_64 /usr/local/bin/docker-compose

3. 执行如下命令：添加可执行的权限
   sudo chmod +x /usr/local/bin/docker-compose
   4.验证docker-compose
docker-compose -v
   

4.3 Compose常用命令

操作描述	命令示例
查看帮助	docker-compose -h
创建并运行所有容器	docker-compose up
创建并后台运行所有容器	docker-compose up -d
指定模板	docker-compose -f docker-compose.yml up -d
停止并删除容器、网络、卷、镜像	docker-compose down
查看容器输出日志	docker-compose logs
拉取依赖镜像	docker-compose pull
检查配置	docker-compose config
检查配置，有问题才有输出	docker-compose config -q
重启服务	docker-compose restart
启动服务	docker-compose start
停止服务	docker-compose stop

4.5 Compose入门

案例
流程：

1. 需要定义一个docker-compose.yml文件----工程 (用idea创建 idea有提示)

version: '3.0'
services:tomcat: ##服务名称image: tomcat:8 #镜像文件名称ports:- 8080:8080

2. 需要在docker-compose文件配置依赖服务
3. docker-compose up 执行该文件

Compose模板文件

version: '3.0'
services:tomcat80: ##服务名称#container_name: tomcat8080 指定容器名称image: tomcat:8 #镜像文件名称 run imagesports:  ###端口号的映射 -p- 8080:8080volumes: ## 数据源 宿主机与容器数据共享  -v- /usr/tomcat/webapps:/usr/local/tomcat/webappsnetworks:  ###定义网络的桥- mayikttomcat81: ##服务名称#container_name: tomcat8080 指定容器名称image: tomcat:8 #镜像文件名称ports:  ###端口号的映射- 8081:8080volumes: ## 数据源 宿主机与容器数据共享- /usr/tomcat/webapps:/usr/local/tomcat/webappsnetworks:- mayikt
networks:  ## 定义服务的桥mayikt:

Compose常用命令

操作描述	命令示例
列出项目中所有的容器	docker-compose ps
停止docker-compose	docker-compose stop
查看容器中日志信息	docker-compose logs
拉取服务依赖的镜像	docker-compose pull

Compose常用配置

项	描述
Image	镜像名称
Build	根据 Dockerfile 打包成镜像
Context	指定 Dockerfile 文件位置
Command	使用 command 可以覆盖容器启动后默认执行的命令
Container_name	容器名称
depends_on	指定依赖的服务
Ports	映射的端口号
extra_hosts	会在 /etc/hosts 文件中添加一些记录
Volumes	持久化目录
volumes_from	从另外一个容器挂载数据卷
Dns	设置 DNS

4.6 Compose部署springboot项目

定义Compose文件

version: "3.0"
services:mysql: # mysql服务image: mysql:5.7command: --default-authentication-plugin=mysql_native_password #解决外部无法访问ports:- "3306:3306"      #容器端口映射到宿主机的端口environment:MYSQL_ROOT_PASSWORD: 'root'MYSQL_ALLOW_EMPTY_PASSWORD: 'no'MYSQL_DATABASE: 'mayikt'MYSQL_USER: 'mayikt'MYSQL_PASSWORD: 'mayikt'networks:- mayikt_webmayikt-web: #自己单独的springboot项目hostname: mayiktbuild: ./     #需要构建的Dockerfile文件ports:- "38000:8080"      #容器端口映射到宿主机的端口depends_on:      #web服务依赖mysql服务，要等mysql服务先启动- mysqlnetworks:- mayikt_web
networks:  ## 定义服务的桥mayikt_web:

Spring项目配置

spring:profiles:active: prddatasource:url: jdbc:mysql://mysql:3306/mayikt?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTCusername: rootpassword: rootdriver-class-name: com.mysql.jdbc.Driver
server:###端口号port: 8080servlet:##设置springboot项目访问路径context-path: /mayikt

4.7 Docker可视化工具使用

Portainer
Portainer是一款Docker可视化管理工具，允许我们在网页中方便的查看和管理Docker容器。
要使用Portainer很简单，运行下面两条命令即可。这些命令会创建一个Portainer专用的卷，然后在8000和9000端口创建容器并运行。

启动：

docker run -d -p 9000:9000 --name=portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer

–name 参数指定容器的名称为 portainer
–restart=always 参数设置容器在启动时自动重启
两个 -v 参数用于将主机上的 /var/run/docker.sock 映射到容器的 /var/run/docker.sock以及将 portainer_data 卷映射到容器的 /data 目录
portainer/portainer 是指要使用的 Portainer 镜像

CentOS Docker 安装
docker rm $(docker ps -aq)
docker stop $(docker ps -q) & docker rm $(docker ps -aq) --停止所有的容器
docker rmi $(docker images -q) —删除所有的容器
docker network ls

Linux关闭防火墙命令
systemctl stop firewalld