docker入门和docker应用场景，常用命令服务管理、镜像管理、容器管理[端口映射、创建Redis容器、数据卷、创建nginx容器、挂载目录]镜像弄一个，服务编排，docker私服

一、简介

• docker解决了什么问题
• docker和虚拟机的区别
• 在CentOS7里安装docker

1. docker简介

解析：

 解决了：

             软件环境的迁移问题

我们写的代码会接触到好几个环境：开发环境、测试环境以及生产环境等等。多种环境去部署同一份代码，由于环境原因往往会出现软件跨环境迁移的问题（也就是“水土”不服）

针对这种问题如何解决？我们可以将工程及此工程依赖的所有软件打包到一个容器中统一部署  

1 什么是docker

docker是什么？主要的应用场景是什么？解决了哪些问题？和虚拟机有什么区别？

Docker 是一个开源的应用容器引擎，基于 Go 语言 并遵从 Apache2.0 协议开源。它可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。

Docker 从 17.03 版本之后分为 CE（Community Edition: 社区版） 和 EE（Enterprise Edition: 企业版），我们用社区版就可以了。

2 docker和虚拟机对比

解析：

区别：

         容器更小，更轻便，更灵活

         虚拟机占用比较大，比较笨重，比较消耗资源

本质的区别：

docker和虚拟机在某些应用场景下比较像，但是docker不是虚拟机。

docker是一种虚拟化容器技术，他和虚拟机最根本的区别是：

docker容器和宿主机共用linux操作系统内核，不会在宿主机上再次安装操作系统。

docker容器运行状态下的本质是宿主机上的进程，通过namespace资源隔离，cgroups资源限制，使它看上去像是一个独立的虚拟机.

 容器

容器是应用层的一个抽象，它将代码和依赖关系打包在一起。

多个容器可以在同一台机器上运行，并与其他容器共享操作系统内核，每个容器作为独立的进程在用户空间运行。

容器比虚拟机占用的空间更小（容器镜像的大小一般为几十MB），可以处理更多的应用，对虚拟机和操作系统的要求也更低。

虚拟机

虚拟机(VM)是物理硬件的抽象，将一台服务器变成多台服务器。

管理程序允许多个虚拟机在一台机器上运行。每个虚拟机都包括一个操作系统、应用程序、必要的二进制文件和库的完整副本--占用几十GB的空间。

虚拟机的启动速度也会很慢。

使用的区别

2. 安装docker

1 docker相关概念

解析：

 概念：

         注册中心：registry，我们可以理解为镜像的仓库。docker hub，USTC

         镜像：image，理解为程序的安装包

         容器：container，理解为程序安装运行起来的实例（一个真正运行起来的软件）

镜像image

Docker 镜像（Image），就相当于是一个文件系统，是用于创建 Docker 容器的模板。也可以将镜像当作容器的“源代码”。镜像体积很小，非常“便携”，易于分享、存储和更新。

容器container

容器是独立运行的一个或一组应用，是镜像运行时的实体。

                                        （相当于是精简版的虚拟机，其中安装好了软件）

注册中心(仓库)registry

Docker 仓库用来保存镜像，有点类似于Maven的远程仓库。Registry 分为公共和私有两种。Docker 公司运营公共的 Registry 叫做 Docker Hub。用户可以在 Docker Hub 注册账号，分享并保存自己的镜像（说明：在 Docker Hub 下载镜像巨慢，可以自己构建私有的 Registry）。

2 安装docker

  

Docker 官方建议在 Ubuntu 中安装，因为 Docker 是基于 Ubuntu 发布的。

由于我们学习的环境都使用的是 CentOS，因此这里我们将 Docker 安装到 CentOS 上。

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

1)安装docker

在安装docker之前，可以先做如下准备工作：

1.  
   #1. 关闭防火墙，并禁止防火墙开机自启
2.  
   systemctl stop firewalld
3.  
   systemctl disable firewalld
4.  
    
5.  
   #2. 关闭MySQL，并禁止MySQL开机自启（你的CentOS里之前安装过MySql，为防止端口冲突，需要做这一步）
6.  
   systemctl stop mysqld
7.  
   systemctl disable mysqld

启动CentOS7后，使用SecureCRT连接上CentOS7，然后依次执行命令（要联网）：

1.  
   # 更新系统，如果需要确认，全部选 y (yes)。根据网络状况，此操作可能要花几分钟或者十几分钟时间
2.  
   yum update
3.  
    
4.  
   # 安装yum-utils工具和两个驱动依赖
5.  
   yum install -y yum-utils device-mapper-persistent-data lvm2
6.  
    
7.  
   # 设置使用阿里云的yum源，稍后会从阿里云下载docker软件
8.  
   yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
9.  
    
10.  
    # 安装docker
11.  
    yum install docker-ce
12.  
     
13.  
    # 查看docker版本
14.  
    docker -v

2 )设置注册中心(仓库)

如果不设置注册中心，将从默认的docker hub里下载镜像，速度非常慢。

USTC（中科大的镜像服务）是老牌的Linux镜像服务提供者（注册中心Registry），从Ubuntu5.04版本就在使用。USTC的docker镜像速度加载很快，它的优势之一是不需要注册，是真正的公共服务。

设置步骤：

1. 创建文件夹：mkdir /etc/docker

2. 编辑文件daemon.json： vi /etc/docker/daemon.json

                   vim /etc/docker/daemon.json

        按字母i进入编辑模式，复制以下内容，在finalShell里右键，粘贴到文件里

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

1. 保存并退出vi：按ESC，输:wq 回车

   然后查看配置的是否正确：cat /etc/docker/daemon.json

2. 重新加载daemon文件，然后重启docker服务：

1.  
   systemctl daemon-reload
2.  
   systemctl restart docker

     3.查看docker信息：docker info，如果能看到以下信息，就说明配置成功了                 

3. 小结****

 docker是什么？解决了哪些问题？和虚拟机有什么区别？主要的应用场景是什么？

Docker是一个开源的容器引擎，它轻巧，且易移植

docker相关的几个概念：
           注册中心：registry，我们理解为镜像的仓库。docker hub， USTC
                  镜像：image，理解为程序的安装包
                  容器：container，理解为程序安装运行起来的实例（一个真正运行起来的软件）

---

传统软件行业中存在的问题：

• 开发、生产、测试环境不一致，开发环境下可用的服务挪到生产上不可用。
• 不同环境之间迁移成本太高，没有统一的软件部署封装标准及封装环境。
• 对于分布式软件持续集成（测试、打包、发布、部署、管理）周期很长，难以自动化、工程化。
• 面临瞬时用户流量增大的场景，很难实现分布式应用服务实例的快速部署。

docker解决了什么问题：

                                     软件环境的迁移问题

---

虚拟机与容器的对比：
                                  容器更小、更轻便、更灵活
                                  虚拟机占用比较大、比较笨重，比较消耗资源

---

docker应用场景

• docker镜像一旦构建，就已经一次性完成了应用自动打包、集成。docker镜像可以进行版本管理、复制、分享、修改，就像管理代码一样。
• 通过统一的docker环境封装（比如镜像中封装了同一版本的JDK、同样的环境变量等等），保证应用服务运行环境的一致性。避免出现在测试环境上好用，挪到生产环境下运行失败的问题。
• docker可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。
• 因为镜像可下载、可复用，docker容器可快速启动等特性，结合容器编排服务(k8s)可以实现大型分布式部署的弹性伸缩，快速扩展。

“build once, configure once and run anywhere”。使用go语言开发，并遵从apache2.0协议。

本质的区别

docker和虚拟机在某些应用场景下比较像，但是docker不是虚拟机。

docker是一种虚拟化容器技术，他和虚拟机最根本的区别是：

docker容器和宿主机共用linux操作系统内核，不会在宿主机上再次安装操作系统。

docker容器运行状态下的本质是宿主机上的进程，通过namespace资源隔离，cgroups资源限制，使它看上去像是一个独立的虚拟机.

 容器

容器是应用层的一个抽象，它将代码和依赖关系打包在一起。

多个容器可以在同一台机器上运行，并与其他容器共享操作系统内核，每个容器作为独立的进程在用户空间运行。

容器比虚拟机占用的空间更小（容器镜像的大小一般为几十MB），可以处理更多的应用，对虚拟机和操作系统的要求也更低。

虚拟机

虚拟机(VM)是物理硬件的抽象，将一台服务器变成多台服务器。

管理程序允许多个虚拟机在一台机器上运行。每个虚拟机都包括一个操作系统、应用程序、必要的二进制文件和库的完整副本--占用几十GB的空间。

虚拟机的启动速度也会很慢。

二、常用命令【重点】

• 能够启动和关闭docker
• 能够管理docker镜像
• 能够管理docker容器

解析：

管理镜像：

               拉取镜像：docker pull 镜像名称：tag

               查看镜像列表：docker images

               删除镜像：docker rmi 镜像名称：tag

管理容器：

                创建容器：docker run -id --name = 容器名称 镜像名称：tag

                查看容器：

                                docker ps     查看正在运行的容器

                                dacker ps -a 查看所有容器

                关闭容器：docker stop 容器名称

                启动容器：docker start 容器名称

                删除容器：docker rm 容器名称

                进入容器：docker exec -it 容器名称 /bin/bash

                从容器里退出回到宿主机：exit

1. 服务管理

1.  
   # 启动docker服务
2.  
   systemctl start docker
3.  
    
4.  
   # 查看docker运行状态
5.  
   systemctl status docker
6.  
    
7.  
   # 重启docker服务
8.  
   systemctl restart docker
9.  
    
10.  
    # 关闭docker服务
11.  
    systemctl stop docker
12.  
     
13.  
    # 设置docker开机自启动
14.  
    systemctl enable docker

安装好docker和设置注册中心(仓库)之后

启动：systemctl start docker

查看：systemctl status docker  如下图： active (running)代表：正在运行状态

设置开机自动启动：systemctl enable docker

2. 镜像管理

 先查看镜像：docker images

拉取镜像 ：docker pull 镜像名称：tag

删除镜像： docker rmi 镜像名称：tag

                   如果一个镜像已经有容器存在了，是不能删除的

                   必须先删除它所有的容器，才能删除镜像

                   查看所有容器： 

                                         

                  删除容器容器:docker rm mq(自已定义的容器名字)    

                                         

                 再继续操作删除镜像即可：docker rmi 镜像名称：tag

                 再查看镜像：docker images 看看还有没有呢

2.1 语法说明

• 拉取镜像：docker pull 镜像名称:tag， 从docker hub拉取镜像包

  从注册中心docker hub把镜像拉取到本地。拉取下来的镜像，在/var/lib/docker目录下存储

  tag：标签名称，相当于版本号。如果不知道版本号，可以从Docker里查询

• 查看镜像：docker images，查看服务器里的所有镜像

• 删除镜像：docker rmi 镜像ID 或者 docker rm 镜像名称:tag

• 加载镜像：docker -i 镜像压缩包（mq.tar）

2.2 使用练习

1. 拉取CentOS7镜像，查看镜像列表（从Docker里搜索CentOS镜像，找到CentOS7）

2. 拉取nginx镜像，查看镜像列表（从Docker里搜索nginx镜像，找到nginx1.14.2）     

   

    拉取CentOS7镜像：docker pull centos:centos7

    

          查看镜像：docker images  这就是下载了镜像了

                                   

          拉取nginx镜像：docker pull nginx:1.14

          查看镜像：docker images

                                     

          等等.....

                          

3. 容器管理

3.1 容器介绍

查看所有容器容器，包括已关闭的容器：docker ps -a          

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

                                               

关闭容器：                                               docker stop 容器名称

删除容器：                                               docker rm 容器名称

容器是独立运行的一个或一组应用，是镜像运行时的实体。（相当于是精简版的虚拟机，其中安装好了软件）

容器的状态有：

• 运行状态：容器正在运行，可以直接使用。

• 暂停状态：容器进程暂停，CPU不再处理容器，但并不释放容器的内存

• 停止状态：容器进程终止，CPU不再处理容器，并释放容器占用的内存

其中操作容器相关的命令有：

• docker run：创建并运行容器

• docker pause：暂停容器

• docker unpause：让容器从暂存中恢复运行

• docker stop：关闭停止容器

• docker start：启动容器

• docker rm：删除容器

3.2 语法说明

• 创建容器：docker run -di --name=容器名称 -p 宿主机端口:容器端口 -v 宿主机目录:容器目录 镜像名称:标签

  命令介绍：根据镜像创建容器并启动运行容器

  参数介绍：

  • d：创建出来的容器在后台运行

  • i：开启STDIN交互（让容器处理活动状态）

  • name：用于设置容器名称

  • p：用于设置 宿主机端口 与 容器端口的映射

  • v：用于设置 宿主机数据卷(或文件夹) 与 容器文件夹的映射

                docker run -di --name=容器名称 镜像名称:标签

               

• 查看容器：

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

  • docker ps：查看运行状态的容器        

  • 

    

• 进入容器：

• 

• 

• • 进入容器内部：docker exec -it 容器名 /bin/bash

• 

• 

• 

• • 退出容器(回到宿主机)：exit （在容器内执行，是退出容器回到宿主机）

  • 

• 关闭容器：docker stop 容器id或名称

• 

• 

• 启动容器：docker start 容器id或名称

• 删除容器：docker rm 容器id或名称

3.3 练习:创建CentOS容器

要求：

• 创建CentOS7容器并启动

• 查看所有正在运行的容器

• 进入容器内部，查看容器里面的目录结构

• 退出容器回到宿主机

• 关闭容器

• 删除容器

3.4 端口映射

之前我们创建的所有容器，并不涉及其中文件的修改。但是如果要创建一个nginx容器，或者tomcat容器，如何把项目传输到容器内部呢？docker提供了数据卷的功能，用于实现宿主机目录与容器目录的映射，这样我们在宿主机目录里的一切操作，都会作用到容器目录里了。

解析：

数据卷常用命令

创建redis镜像：docker pull redis:5.0

查看镜像：doocker images

1.创建容器 ：docker run -di -name=myredis redis:5.0

   1.1查看运行redis运行状态：docker ps 

     1.2:做端口映射：docker myredis -p 6379:6379

 2.创建容器时，可以进行端口映射

docker run -id --name=容器名称 -v 数据卷名称:容器内目录 -p 宿主机端口:容器端口 镜像名称:tag

docker run -id --name=myredis -p 宿主机端口:容器端口 镜像名称:tag

docker run -id --name=myredis -p 6379:6379 redis5.0

宿主机和容器的关系：

• docker所在的主机，称为宿主机；docker里还有容器

为什么要做端口映射：

• 每个容器都相当于一个独立的服务器，服务器之间是一个小型局域网，外界的客户端不能访问某一个容器

• 所以要做一个端口映射：宿主机的一个端口号---容器里的一个端口号。两个端口建议相同

• 这样：客户端就能通过“宿主机:端口”，访问到映射的容器端口

练习:创建nginx容器

3.5 练习:创建Redis容器

要求：

• 创建redis容器并启动，暴露端口6379

• 查看所有正常运行的容器

• 然后用RDM工具访问redis

要求：

• 创建MySql容器并启动，暴露端口3306

• 查看所有正在运行的容器

• 然后使用Navicat或其它工具连接MySQL

1.  
   # 拉取镜像
2.  
   docker pull mysql:5.7
3.  
    
4.  
   # 创建容器
5.  
   docker run -id --name=mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root mysql:5.7 --character-set-server=utf8

3.7 数据卷

介绍

之前我们创建的所有容器，并不涉及其中文件的修改。但是如果要创建一个nginx容器，或者tomcat容器，如何把项目传输到容器内部呢？docker提供了数据卷的功能，用于实现宿主机目录与容器目录的映射，这样我们在宿主机目录里的一切操作，都会作用到容器目录里了。

常用命令

操作数据卷的命令

 列出所有数据卷：docker volumn ls 

创建数据卷：docker volume create 数据卷名称

        列出所有数据卷：docker volumn ls

查看数据卷详情：docker volumn inspect 数据卷名称

删除数据卷：docker volumn rm 数据卷名称

给容器挂载数据卷

在创建容器时，可以通过-v参数，将数据卷挂载给容器内的某个目录：

• docker run -id --name=容器名称 -v 数据卷名称:容器内目录 -p 宿主机端口:容器端口 镜像名称:tag

使用示例

3.8 练习:创建nginx容器

要求：创建一个nginx容器，修改nginx内的html页面

已知：nginx内html目录的位置是 /usr/share/nginx/html

提示：

1. 创建一个数据卷，名称为html。查看数据卷的文件夹位置

   创建数据卷docker volume create html

   查看数据卷docker volume inspect html

2. 

3. 创建nginx容器，使用-v参数把数据卷html挂载绑定到容器内的/usr/share/nginx/html

   docker run -id --name=mynginx -v html:/usr/share/nginx/html -p 80:80 nginx:1.14.2

 

 

1. 使用浏览器访问nginx，先查看原始index.html页面的效果

   浏览器输入地址：http://宿主机ip:80

2. 直接进入数据卷html的目录，修改其中的index.html文件

   cd /var/lib/docker/volumes/html/_data

   使用vi修改其中的index.html文件，之后保存并退出vi

3. 再使用浏览器访问nginx，查看修改后的index.html页面效果

   浏览器输入地址：http://宿主机ip:80

3.5 挂载目录

3.5.1 语法说明

容器不仅仅可以挂载数据卷，也可以直接挂载到宿主机目录上。

挂载目录的语法，和挂载数据卷的语法是类似的，都是使用参数-v：

• 挂载数据卷：-v 数据卷:容器内目录

• 挂载目录：-v 宿主机目录:容器内目录

  注意：“宿主机目录”要以绝对路径的形式提供。以/开头的路径

3.5.2 练习:创建tomcat容器

要求：创建一个tomcat容器，修改mysql内的html页面

已知：tomcat内webapps目录的位置是/usr/local/tomcat/webapps

提示：

1. 创建文件夹/root/webapps

   mkdir /root/webapps

2. 创建nginx容器，使用-v参数把/root/webapps挂载绑定到容器内的/usr/local/tomcat/webapps

   docker run -id --name=mytomcat -p 8080:8080 -v /root/webapps:/usr/local/tomcat/webapps tomcat:8.5.88

3. 把资料中的appfront文件夹上传到/root/webapps文件夹里

4. 再使用浏览器访问tomcat，访问 http://宿主机ip:8080/appfront/index.html

4. 小结

四、镜像制作【了解】

1. 镜像原理

1. 镜像原理

操作系统的组成

镜像原理

制作镜像的方式

• 使用一个已有容器，生成镜像，保存成文件：备份与恢复

• 基于一个基础镜像，构造一个新的镜像：Dockerfile

2. 备份与恢复

2.1 把容器保存成镜像

• 命令：docker commit 容器名称 自定义一个镜像名称

• 示例：docker commit redis myredisimage

2.2 镜像备份

• 命令：docker save -o 文件名称 镜像名称

• 参数：

  • o：output，表示要输出到文件

• 说明：

  • 文件名称，通常是xxx.tar打包文件

• 示例：docker save -o myredisimage.tar myredisimage

2.3 镜像恢复

• 命令：docker load -i xxx.tar

• 参数：

  • i：input，表示要从文件读取

• 示例：

  • 我们先将原有镜像删除掉：docker rmi myredisimage:latest

  • 从xxx.tar恢复镜像：docker load -i myredisimage.tar

3. Dockerfile

3.1 Dockerfile介绍

前边讲的commit方式，是从一个已有容器生成一个镜像。而Dockerfile是另外一种构建镜像的方式，它是以一种基础镜像为基础，编写一系列的docker指令，每条指令构建一层镜像，通过这些指令一层层构建出一个目标镜像出来。

• 对于开发人员：可以为开发团队提供一个完全一致的开发环境

• 对于测试人员：可以直接拿开发时所构建的镜像或者通过Dockerfile文件构建一个新的镜像开始工作了

• 对于运维人员：在部署时，可以实现应用的无缝移

Dockerfile的基本指令有十三个，分别是：

关键字	作用	备注
FROM	指定父镜像	指定dockerfile基于那个image构建
MAINTAINER	作者信息	用来标明这个dockerfile谁写的
LABEL	标签	用来标明dockerfile的标签 可以使用Label代替Maintainer 最终都是在docker image基本信息中可以查看
RUN	执行命令	执行一段命令 默认是/bin/sh 格式: RUN command 或者 RUN ["command" , "param1","param2"]
CMD	容器启动命令	提供启动容器时候的默认命令 和ENTRYPOINT配合使用.格式 CMD command param1 param2 或者 CMD ["command" , "param1","param2"]
ENTRYPOINT	入口	一般在制作一些执行就关闭的容器中会使用
COPY	复制文件	build的时候复制文件到image中
ADD	添加文件	build的时候添加文件到image中 不仅仅局限于当前build上下文 可以来源于远程服务
ENV	环境变量	指定build时候的环境变量 可以在启动的容器的时候 通过-e覆盖 格式ENV name=value
ARG	构建参数	构建参数 只在构建的时候使用的参数 如果有ENV 那么ENV的相同名字的值始终覆盖arg的参数
VOLUME	定义外部可以挂载的数据卷	指定build的image那些目录可以启动的时候挂载到文件系统中 启动容器的时候使用 -v 绑定 格式 VOLUME ["目录"]
EXPOSE	暴露端口	定义容器运行的时候监听的端口 启动容器的使用-p来绑定暴露端口 格式: EXPOSE 8080 或者 EXPOSE 8080/udp
WORKDIR	工作目录	指定容器内部的工作目录 如果没有创建则自动创建 如果指定/ 使用的是绝对地址 如果不是/开头那么是在上一条workdir的路径的相对路径
USER	指定执行用户	指定build或者启动的时候 用户 在RUN CMD ENTRYPONT执行的时候的用户
HEALTHCHECK	健康检查	指定监测当前容器的健康监测的命令 基本上没用 因为很多时候 应用本身有健康监测机制
ONBUILD	触发器	当存在ONBUILD关键字的镜像作为基础镜像的时候 当执行FROM完成之后 会执行 ONBUILD的命令 但是不影响当前镜像 用处也不怎么大
STOPSIGNAL	发送信号量到宿主机	该STOPSIGNAL指令设置将发送到容器的系统调用信号以退出。
SHELL	指定执行脚本的shell	指定RUN CMD ENTRYPOINT 执行命令的时候 使用的shell

从前面的内容可以看出，要构建一个容器，需要做很多的工作，设置很多的配置，如果我们可以把每一层修改、安装、构建、操作的命令都写入一个脚本，用这个脚本来构建、定制镜像，那么之前提及的无法重复的问题、镜像构建透明性的问题、体积的问题就都会解决。 这个脚本就是 Dockerfile。

3.2 Dockerfile示例

需求

定义dockerfile，发布springboot项目

分析

1. SpringBoot项目可以独立运行，不需要Tomcat；但是需要有jdk

   所以：我们这个容器，要提供基础的jdk环境，基于jdk环境构造一个新容器

   使用：FROM java:8

2. 要把SpringBoot项目添加到这个容器里

   使用：ADD demo.jar /demo.jar

3. 当启动容器时，要同时启动运行这个SpringBoot项目

   所以：启动容器时，要执行Java命令，运行SpringBoot项目

实现

1. 把SpringBoot项目上传到宿主机

在宿主机里创建一个文件夹~/dockerfiles，把SpringBoot工程打包为demo.jar，然后上传到CentOS的~/dockerfiles里

2. 创建Dockerfile

在~/dockerfiles文件夹里创建文件Dockerfile，内容如下：

1.  
   #1.定义父镜像：
2.  
   FROM java:8
3.  
   #2.定义作者信息：
4.  
   MAINTAINER itheima <itheima@itcast.cn>
5.  
   #3.将jar包添加到容器：
6.  
   ADD demo.jar /demo.jar
7.  
   #4.定义容器启动执行的命令： 当通过此镜像启动容器的时候，执行的命令
8.  
   CMD java -jar /demo.jar

3. 通过Dockerfile构建镜像

1.  
   # 切换到dockerfile文件所在的路径
2.  
   cd ~/dockerfiles
3.  
    
4.  
   # 构建镜像
5.  
   docker build -f ./Dockerfile -t demo:1 ./

4. 启动容器

1.  
   #创建启动容器
2.  
   docker run -id --name=自定义名称 -p 端口 镜像名称
3.  
    
4.  
   docker run -id --name=demo -p 81:80 demo:1
5.  
    
6.  
   #打开浏览器，输入地址 http://宿主机ip:81/hello ，可以访问到SpringBoot项目

五、服务编排

1. 服务编排介绍

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

Docker compose是一个用于定义和运行多个Docker容器的编排工具。可以一条命令启动多个容器。主要是解决了容器与容器之间如何管理编排的问题。

使用Docker compose 有三个步骤：

1. 利用Dockerfile定义运行环境（如果已有镜像，可省略这一步）

2. 使用docker-compose.yml定义组成应用的各服务

3. 运行docker-compose up -d启动应用

2. 安装docker compose

1.  
   # 下载docker compose
2.  
   curl -L https://github.com/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
3.  
    
4.  
   # 设置权限
5.  
   chmod x /usr/local/bin/docker-compose
6.  
    
7.  
   # 查看版本
8.  
   docker-compose -version

如果要卸载docker-compose，可执行如下命令：

1.  
   # docker compose是二进制包方式安装的，删除二进制文件即可
2.  
   rm /usr/local/bin/docker-compose

3. 服务编排示例

要求：通过docker-compose 批量创建三个容器（nginx，tomcat，redis）

1. 创建docker-compose目录

1.  
   mkdir ~/docker-compose
2.  
   cd ~/docker-compose

编写docker-compose.yaml文件

1.  
   version: "3.0"
2.  
   services:
3.  
   redis:
4.  
   container_name: redis
5.  
   image: redis:5.0
6.  
   ports:
7.  
   - 6379:6379
8.  
   nginx:
9.  
   container_name: nginx
10.  
    image: nginx
11.  
    ports:
12.  
    - 80:80
13.  
    volumes:
14.  
    - /root/volumes/nginx/html:/usr/share/nginx/html
15.  
    tomcat:
16.  
    container_name: tomcat
17.  
    image: tomcat:8.5
18.  
    ports:
19.  
    - 8080:8080
20.  
    volumes:
21.  
    - /root/volumes/tomcat/webapps:/usr/local/tomcat/webapps

启动。

1.  
   # ！！！注意：必须先切换到`docker-compose.yaml`文件所在的目录后，才可以执行以下命令！！！
2.  
   cd ~/docker-compose
3.  
    
4.  
   # docker-compose up -d 以守护进程方式创建并启动容器
5.  
   docker-compose up -d

4. 常用命令 【掌握】

1.  
   # ！！！注意：必须先切换到`docker-compose.yaml`文件所在的目录后，才可以执行以下命令！！！
2.  
   # ！！！注意：如果还没有创建过容器时，执行这个命令可以创建并启动。如果容器已存在，就不要用这个命令了！！！
3.  
   docker-compose up -d
4.  
    
5.  
   # ！！！注意：如果容器已经创建过了，就执行这个命令，直接启动即可。不要再用 up -d 的那个命令了！！！
6.  
   docker-compose start # 启动容器
7.  
    
8.  
   # 了解其它命令：
9.  
   docker-compose help # 查看帮助
10.  
    docker-compose stop # 停止容器
11.  
    docker-compose start # 启动容器
12.  
    docker-compose restart # 重启容器
13.  
    docker-compose rm # 删除已停止的容器
14.  
    docker-compose down # 停止并删除容器

5. 小结

六、docker私服【拓展了解】

我们知道docker镜像可以托管到Docker Hub中，跟代码库托管到github是一个道理。但如果我们不想把docker镜像公开放到Docker Hub中，只想在部门或团队内部共享docker镜像，能不能项gitlab一样在搭建私有的仓库呢？答案是肯定的，docker也支持将镜像存到私有仓库。

 

1. 搭建私服

1 拉取私服镜像

1.  
   # 拉取私服镜像
2.  
   docker pull registry
3.  
   # 启动运行私服
4.  
   docker run -id --name=registry -p 5000:5000 registry

2 设置私服容器

设置私有仓库为可信任，用vim编辑文件 /etc/docker/daemon.json

"insecure-registries":["私有仓库的ip:端口"]

• 重启docker：systemctl restart docker

• 打开浏览器，通过网址：http://192.168.247.140:5000/v2/_catalog来验证是否启动成功

2. 上传镜像到私服

1. 给镜像打标记成为私有仓库镜像

• 语法：docker tag 镜像名称 私有仓库ip地址:5000/镜像名称

• 示例：docker tag redis:5.0 192.168.247.140:5000/redis:5.0

2. 上传到私有仓库

• 语法：docker push 私有仓库ip地址:5000/镜像名称

• 示例：docker push 192.168.247.140:5000/redis:5.0

• 上传后，可以浏览器上看到

3. 从私服拉取镜像

• 语法：docker pull 私有仓库ip地址:5000/镜像名称

• 示例：docker pull 192.168.247.140:5000/redis:5.0

如何使用..提供的虚拟机

做的事情：

• 把虚拟机打包成一个压缩包《centos_docker.rar》

• 和资料视频一起发给大家

大家做的事情：

• 把压缩包《centos_docker.rar》解压到一个不含中文、空格、特殊字符的目录里

• 使用VMWare，File->Open，选择解压目录里的 centos_docker.vmx 文件

• 可以在VMWare里启动这个虚拟机了

  如果有弹窗，选择“我移动了此虚拟机”

• 可以使用crt连接这个虚拟机，可以在虚拟机里操作docker了

 七、docker应用场景

• docker镜像一旦构建，就已经一次性完成了应用自动打包、集成。docker镜像可以进行版本管理、复制、分享、修改，就像管理代码一样。
• 通过统一的docker环境封装（比如镜像中封装了同一版本的JDK、同样的环境变量等等），保证应用服务运行环境的一致性。避免出现在测试环境上好用，挪到生产环境下运行失败的问题。
• docker可以做到秒级、甚至毫秒级的启动时间。大大的节约了开发、测试、部署的时间。
• 因为镜像可下载、可复用，docker容器可快速启动等特性，结合容器编排服务(k8s)可以实现大型分布式部署的弹性伸缩，快速扩展。

docker与虚拟机的区别：

docker和虚拟机在某些应用场景下比较像，但是docker不是虚拟机。

这篇好文章是转载于：学新通技术网