一 引擎

1. 引擎（Engine）是电子平台上开发程序或系统的核心组件。
   1. 一般而言，引擎是一个程序或一套系统的支持部分。
      1. 常见的程序引擎有游戏引擎、搜索引擎、杀毒引擎等。
         1. 游戏引擎：就是“用于控制所有游戏功能的主程序“。
         2. 搜索引擎：对信息进行采集、组织和处理后，将检索的相关信息展示给用户的系统。
         3. 杀毒引擎：是去检测和发现病毒的程序。

二 镜像

1. 镜像（Mirroring）是一种文件存储形式，是冗余的一种类型。一个磁盘上的数据在另一个磁盘上存在一个完全相同的副本即为镜像。可以把许多文件做成一个镜像文件，与GHOST等程序放在一个盘里用GHOST等软件打开后，又恢复成许多文件。RAID 1和RAID 10使用的就是镜像。常见的镜像文件格式有ISO、BIN、IMG、TAO、DAO、CIF、FCD。镜像（一种文件形式）_百度百科 (baidu.com)

2. 在二维空间里，一个物体（或二维图形）的镜像就是该物体在某平面镜中反射出来的虚像。这时镜像与原物有同样大小，但不尽相同，除非原物本来就是反射对称的（在现代物理学上又称为P对称）。

   在几何学中，镜像，顾名思义，就是物体相对于某镜面所成的像。镜像（几何）_百度百科 (baidu.com)

三 虚拟化技术

1 业务：搭建多台服务器

（1）虚拟化技术前，搭建服务器

1. 购买一台硬件服务器;
2. 在硬件服务器上安装配置操作系统;
3. 在操作系统之上配置应用运行环境;
4. 部署并运行应用;

（2）这种方式的缺点就是：

1. 部署应用非常慢;
2. 需要花费的成本非常高(时间成本、服务器成本) ;
3. 应用迁移麻烦，要将应用迁移，又得重复部署应用的过程：购买服务器->安装操作系统0S->配置运行环境->部署应用

2 想法：把一台服务器的硬件资源进行切割，拆分成多台服务器，这样至少节约了购买硬件的成本

3 解决方案：

（1）功能“集”：服务器的硬件资源进行切割

（2）“神”工具：虚拟化技术

4 完成学习：虚拟化技术

（1）思想

1. 计算机硬件资源的切割,并且以更好的方式来组合应用这些资源。

（2）流原

1. 虚拟化是一种计算机资源管理技术
   1. 将计算机的各种硬件资源，比如服务器、网络、CPU、 内存及存储等，予以抽象和转换后呈现出一套新的硬件资源环境
   2. 在这一套新的硬件环境下可以安装我们的操作系统，部署我们的应用运行环境等
2. 虚拟化一般分为：
   1. 硬件级虚拟化
   2. 操作系统级虚拟化
3. 硬件级虚拟化，如虚拟机VMWare：
   1. 是运行在硬件之上的虚拟化技术
   2. 核心技术是Hypervisor，是一种运行在基础物理服务器硬件之上的软件层，可以虚拟化硬件资源，例如cpu、硬盘、内存资源等。然后我们可以通过在虚拟化出来的资源之上安装操作系统。这也就是所谓的虚拟机。像VMWare, VirtualBox 等都是使用该技术，我们经常使用的桌面版的虚拟机VMWare就是采用这种虚拟化技术。
   3. 如下图所示：
      ​
   4. 优点：
      1. 通过Hypervisor层,我们可以创建不同的虚拟机，并且每个虚拟机都是分离、独立的，这样一来,我们就可以在一台硬件服务器和本地操作系统之上虚拟化出多个服务器，用来部署我们的应用;
      2. 一台物理服务器可以虚拟化出多个虚拟的服务器,让计算机资源得以充分利用;
   5. 缺点：
      1. 每创建一个虚拟机的时候，都会安装一个操作系统，这个操作系统会占用很多资源,这样无疑大大的增加了资源的消耗，当安装的虚拟机越多，资源消耗就越多。
      2. 环境兼容性问题，开发时的环境运行正常，部署到虚拟机环境测试则有可能发生错误;
4. 操作系统级虚拟化：
   1. 是运行在操作系统之上的虚拟化技术。
   2. 核心技术是容器化技术。它模拟的是运行在一个操作系统上的多个不同进程,并将其封装在一个密闭的容器里面。
   3. 在容器化技术领域，Docker 是目前最流行的一种实现。

四 Docker

1 业务：开发环境与运维环境

2 问题：项目移植时，开发环境与运维环境不一致

3 解决方案：

（1）功能“集”：容器化技术的实现

（2）“神”工具：docker

4 完成学习：

（1）体系组织

1. 容器化技术，实现，docker
   1. Docker是基于LXC技术的核心管理弓|擎。在Lxc的基础上Docker 进行了进一步的封装。
      1. LXC是Linux平台上的容器化技术实现。
      2. 注:LXC是Linux Container的简写，它是一种内核虚拟化技术,可以提供轻量级的虚拟化，以便隔离进程和资源，它与宿主机使用同一个内核，性能损耗小，这种技术是Linux提供的，但是直到Docker出世，该技术才被发挥出来。
   2. Docker是Go语言开发，并遵从Apache2.0协议开源，GitHub：https://github.com/docker/docker-ce。
   3. Ubuntu、CentOS、Debian、Fedora等主流的Linux操作系统都支持Docker;
   4. Docker 可以在很多平台上运行，无论是物理机、 虚拟机、公有云、私有云，甚至是笔记本，其运行结果是一致的。
2. Docker 使用客户端-服务器 (C/S) 架构模式，使用远程API来管理和创建Docker容器。
   ​
   ​
3. Docker包括三个核心要素：镜像(Image)、容器(Container) 、仓库(Repository)
   1. 镜像(Image)
      1. 作用：创建Docker容器
         1. 对开发和运维人员来说，最希望的就是一次创建或配置，可以在任意地方正常运行。
         2. 使用 Docker 可以通过定制应用镜像来实现持续集成、持续交付、部署。
            1. 开发人员可以通过 Dockerfile 来进行镜像构建，并结合持续集成系统进行集成测试，而运维人员则可以直接在生产环境中快速部署该镜像，甚至结合持续部署系统进行自动部署。而且使用 Dockerfile 使镜像构建透明化，不仅仅开发团队可以理解应用运行环境，也方便运维团队理解应用运行所需条件，帮助更好的生产环境中部署该镜像。
            2. 所以 Docker 可以简化部署多种应用实例工作。比如 Web 应用、后台应用、数据库应用、大数据应用比如 Hadoop 集群、消息队列等等都可以打包成一个镜像部署。
      2. 组成结构：
         1. Docker镜像是由文件系统叠加而成（是一种文件的存储形式）。
            1. 镜像是由许多层的文件系统叠加构成的：
               1. 最下面是一个引导文件系统bootfs
               2. 第二层是一个root文件系统rootfs，root 文件系统通常是某种操作系统，比如centos、 Ubuntu,
               3. 在root 文件系统之上又有很多层文件系统
         2. 如下图：
            ​
            ​

      3. 主要内容：
         1. Docker 镜像中包含了运行环境和配置
            1. 运行环境：centos操作系统环境、运行时所需的程序、库、资源、配置等。
            2. 配置：还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）
      4. 特性：
         1. 镜像不包含任何动态数据，其内容在构建之后也不会被改变
      5. 日常操作：
         1. 创建镜像
         2. 搜索镜像：docker search 镜像名称

            1. NAME：仓库名称

            2. DESCRIPTION：镜像描述

            3. STARS：用户评价，反应一个镜像的受欢迎程度

            4. OFFICIAL：是否官方

            5. AUTOMATED：自动构建，表示该镜像由Docker Hub自动构建流程创建的

         3. 下载（拉取）镜像，拉取镜像相当于从远程Registry中下载镜像到本地
            1. 方式1：从官方镜像仓库下载：docker pull 镜像名称:tag

               1. 其中:tag可以省略，省略时下载镜像最新版本（lastest）

               2. 比如，下载redis镜像: docker pull redis:latest
                  1. reids是查询到的镜像名称
                  2. latest 是镜像的标签tag
            2. 方式2：自己通过Dockerfile文件构建。
            3. 方式3：从其他人那里下载一个镜像
         4. 列出已经下载的镜像:
            1. docker images,或者docker images redis

               1. REPOSITORY：镜像所在的仓库名称

               2. TAG：镜像标签（其实就是版本）

               3. IMAGE ID：镜像ID

               4. CREATED：镜像的创建日期（不是获取该镜像的日期）

               5. SIZE：镜像大小

         5. 运行镜像
            1. docker run -d redis其中-d表示在后台运行
         6. 查看
            1. 查看镜像中应用的启动状态：通过ps -ef | grep redis可以查到redis进程
            2. 查看本地镜像的 IMAGE ID：docker images -q
            3. 查看⼀个镜像的制作历程 ：docker history 镜像名称
         7. 更新镜像
         8. 删除镜像

            1. 删除本地镜像使用命令：

               docker rmi $IMAGE_ID

               docker rmi $REPOSITORY:TAG

         9. 保存镜像
            1. 备份本地仓库的镜像
               1. ⽤ save ⼦命令将本地仓库的镜像保存当前⽬录下
               2. 将本地目录下的镜像备份文件导⼊到本地 Docker 仓库
   2. 容器(Container)：从镜像创建的运行实例。
      1. 思想：
         1. 容器的实质是运行着的进程，容器进程独立于宿主，并且和其它的进程上隔离的。
         2. 可以把看做一个简易版的Linux环境，包括root 用户权限、进程空间、用户空间和网络空间和运行在其中的应用程序。
         3. 简单的说，容器是独立运行的一个或一组应用，以及它们的运行环境。
         4. 由于隔离的进程独立于宿主和其它的隔离的进程，因此也称其为容器。
         5. 容器还可以进行版本管理、复制、分享、修改，就像管理普通的代码一样。
         6. 容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）,更重要的是容器性能开销极低。沙箱机制
      2. 组成结构：
         1. Docker利用容器来运行应用。
         2. 镜像是只读的，容器在启动的时候创建一层可写层作为最上层。
         3. 每个容器都是相互隔离的、保证安全平台。
         4. 如下图所示：
            ​
      3. 新建：docker create [options] 镜像名字或者ID [COMMAND] [ARG...]
         1. 写法1：docker create -p 3306:3306 --name suiyi -e MYSQL_ROOT_PASSWORD=smallming mysql:5.7 
         2. 写法2：

            docker create -p 3306:3306 --name mysql_new -e MYSQL_ROOT_PASSWORD=root \

            -v /usr/local/docker/mysql/conf:/etc/mysql \

            -v /usr/local/docker/mysql/logs:/var/log/mysql \

            -v /usr/local/docker/mysql/data:/var/lib/mysql \

            mysql

            1. --name：给容器起一个新名字。为容器指定一个名称

            2. -P：随机端口映射

            3. -p：指定端口映射，hostPost：containerPort

            4. -e：配置信息

            5. -v：主机和容器的目录映射关系，":"前为主机目录，之后为容器目录

            6. MYSQL_ROOT_PASSWORD：root用户的密码

            7. 最后的mysql是镜像，没有tag时表示:lastest最新版本。

      4. 新建并启动容器：docker run [options] 镜像名字或者ID  [COMMAND] [ARG...]

         1. 写法1：docker run -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7

         2. 写法2：

            docker run -p 3306:3306 --name mysql_new -e MYSQL_ROOT_PASSWORD=root \

            -v /usr/local/docker/mysql/conf:/etc/mysql \

            -v /usr/local/docker/mysql/logs:/var/log/mysql \

            -v /usr/local/docker/mysql/data:/var/lib/mysql \

            -d mysql

         3. 可用参数说明：

            docker run --help -d, --detach=false         指定容器运行于前台还是后台，默认为false -i, --interactive=false    打开STDIN，用于控制台交互 -t, --tty=false            分配tty设备，该可以支持终端登录，默认为false -u, --user=""              指定容器的用户 -a, --attach=[]            登录容器（必须是以docker run -d启动的容器） -w, --workdir=""           指定容器的工作目录 -c, --cpu-shares=0         设置容器CPU权重，在CPU共享场景使用 -e, --env=[]               配置信息 -m, --memory=""            指定容器的内存上限 -P, --publish-all=false      随机暴露容器的端口 -p, --publish=[]           指定容器暴露的端口 -h, --hostname=""          指定容器的主机名 -v, --volume=[]            给容器挂载存储卷，挂载到容器的某个目录 --volumes-from=[]          给容器挂载其他容器上的卷，挂载到容器的某个目录 --cap-add=[]               添加权限，权限清单详见：http://linux.die.net/man/7/capabilities --cap-drop=[]              删除权限，权限清单详见：http://linux.die.net/man/7/capabilities --cidfile=""               运行容器后，在指定文件中写入容器PID值，一种典型的监控系统用法 --cpuset=""                设置容器可以使用哪些CPU，此参数可以用来容器独占CPU --device=[]                添加主机设备给容器，相当于设备直通 --dns=[]                   指定容器的dns服务器 --dns-search=[]            指定容器的dns搜索域名，写入到容器的/etc/resolv.conf文件 --entrypoint=""            覆盖image的入口点 --env-file=[]              指定环境变量文件，文件格式为每行一个环境变量 --expose=[]                指定容器暴露的端口，即修改镜像的暴露端口 --link=[]                  指定容器间的关联，使用其他容器的IP、env等信息 --lxc-conf=[]              指定容器的配置文件，只有在指定--exec-driver=lxc时使用 --name=""                指定容器名字，后续可以通过名字进行容器管理，links特性需要使用名字 --network="bridge"            容器网络设置:                             bridge 使用docker daemon指定的网桥  默认                             host    //容器使用主机的网络，不需要使用-p发布端口绑定。容器没有其他的虚拟网络                             container:NAME_or_ID  >//使用其他容器的网路，共享IP和PORT等网络资源                             none 容器使用自己的网络（类似--net=bridge），但是不进行配置 --privileged=false         指定容器是否为特权容器，特权容器拥有所有root权限 --restart="no"             指定容器停止后的重启策略:                               no：容器退出时不重启                               on-failure：容器故障退出（返回值非零）时重启                               always：容器退出时总是重启 --rm=false                 指定容器停止后自动删除容器(不支持以docker run -d启动的容器) --sig-proxy=true           设置由代理接受并处理信号，但是SIGCHLD、SIGSTOP和SIGKILL不能被代理

      5. 启动：docker start 容器ID
         1. 方式1：基于镜像新建一个容器并启动
            1. 通过镜像启动容器: docker run -d redis
         2. 方式2：将在终止状态的容器重新启动
            1. 已经停止的容器，我们可以使用命令docker start来启动。
            2. 开启容器: docker start容器id或容器名称
      6. 重启：
         1. 重启已关闭容器：docker restart 9be696a0c283//启动容器（根据ID或NAMES）
      7. 查看：

         1. 查看docker容器进程信息： docker ps [options]

            1. 查看运行中的容器：docker ps

            2. 查看所有的容器：docker ps -a

            3. 参数说明：

               -l：显示最近创建的容器

               -n 数字：显示最近n个创建的容器

               -a：列出所有的运行过的容器

               -q：列出容器id

         2. 列出正在运行的容器： docker container ls

         3. 还可以使用docker inspect +容器id或容器名称查看容器的更多信
            息;
      8. 与运行中的容器交互

         1. docker exec [options] 容器ID [command]

            例如：docker exec -it mysql /bin/bash

         2. options参数说明

            1. -i：以交互模式运行容器，通常与-t连用

            2. -t：为容器重新分配一个伪终端，通常与-i连用

      9. 停止：docker stop 容器ID
         1. 停止容器: docker stop 容器id或容器名称
         2. 停用全部运行中的容器: docker stop $(docker ps -q)
         3. 强制停止容器：不推荐使用，容易造成容器服务不正常关闭，影响后续使用。
            1. docker kill 容器ID
            2. docker kill mysql
      10. 删除：docker rm 容器ID。要删除的容器，必须是关闭状态的。
          1. 删除容器: docker rm容器id或容器名称
          2. 删除容器时，容器必须是停止状态，否则会报错;
          3. 删除全部容器: docker rm $(docker ps -aq)
      11. 停止并删除：
          1. 一条命令实现停用并删除容器:
             docker stop $(docker ps -q) & docker rm-f $(docker ps -aq)
      12. 进入
          1. 进入容器: docker exec -it容器id或容器名称bash
      13. 查看容器中运行的进程：可以知道容器中到底运行的是哪个应用程序。

          1. docker top 容器ID

             docker top mysql

      14. 查看容器|镜像内部详情
          1. docker inspect 容器ID

          2. docker inspect 镜像ID

          3. docker inspect mysql

      15. 复制容器数据到宿主机
          1. docker cp 容器ID:容器内路径 宿主机路径

          2. docker cp 宿主机路径 容器ID:容器内路径

          3. 复制MySQL配置到宿主机：  docker cp mysql:/etc/mysql ~/tmp/conf

   3. 仓库(Repository)：集中存放镜像文件的场所,有时候会把仓库和仓库注册服务器
      (Registry)看做同一事物，并不严格区分。
      1. 1个仓库注册服务器，n个仓库。
         1. 1个仓库，n个镜像。
            1. 1个镜像，有不同的标签(tag) 。
      2. 思想：
         1. 注: Docker仓库的概念跟Git 类似。
         2. 注册服务器也类似于GitHub 这样的托管服务。
      3. 分类
         1. 公开仓库(Public)
            1. 最大的公开仓库是Docker Hub (https://hub. docker.com/)，存放了
               数量庞大的镜像供用户下载;
         2. 私有仓库( Private)
            1. 当然，用户也可以在本地网络内创建一个私有仓库;
      4. 日常操作：Public 或 Private
         1. 查找官方仓库中的镜像：
            1. docker search ra bbitmq
               1. 镜像名字、
               2. 描述、
               3. 星级(表示该镜像的受欢迎程度)、
               4. 是否官方创建、
               5. 是否自动创建;
         2. 上传：
            1. push命令：docker pull rabbitmq
         3. 下载：
            1. pull命令：docker pull centos
      5. 私有仓库搭建
         1. 拉取镜像仓库：docker pull registry
         2. 查看所有镜像：docker images
         3. 启动镜像服务器registry
            1. 首先在在主机上新建一个目录，供存储镜像
         4. 测试
            1. 从公有镜像仓库中下载一个镜像下来，或本地构建的镜像。然后push到私有仓库进行测试
            2. 此时，访问浏览器私有仓库地址：http://宿主IP:5000/v2/_catalog， 即可看见推送的镜像信息了
         5. IP地址提交，进行安全检验
      6. Harbor介绍及实践
         1. docker 官方提供的私有仓库 registry，用起来虽然简单 ，但在管理的功能上存在不足。

（2）思想

1. docker。Docker是一种轻量级的操作系统虚拟化解决方案 
   1. Docker并不是容器，它是一个管理容器的引擎。
      1. 通过Docker 让开发者可以打包Linux容器中应用的代码及其依赖包（环境，应用之间相互隔离）到一个轻量级、可移植的容器中，打包好的容器可以发布或迁移到任何流行的Linux 服务器上运行。期望达到使项目运行环境“一次封装，到处运行的目的”。
         1. 应用场景：
            1. Web 应用的自动化打包和发布。
            2. 自动化测试和持续集成、发布。
            3. 在服务型环境中部署和调整数据库或其他的后台应用。
            4. 从头编译或者扩展现有的 OpenShix 或 Cloud Foundry 平台来搭建自己的 PaaS 环境。

               IaaS:（Infrastructure-as-a-Service）(基础设施即服务)

               PaaS:（Platform as a Service）(平台即服务)

               SaaS:（Software-as-a-Service）(软件即服务)
2. 镜像：是一种文件存储形式。
3. 容器：
   1. 镜像的实例
   2. 利用docker创建的运行环境叫做docker容器。
   3. docker。通俗一点说，Docker就像一个盒子，里面可以装很多物件，如果需要这些物件的可以直接将该大盒子拿走，而不需要从该盒子中一件件的取。
      1. 可以把容器看成简易版的Linux环境（包含了最基本功能：包括root用户权限，进程空间，用户空间和网络空间等）和运行在其中的应用程序。
      2. 通俗解释：Docker内嵌极小型系统，例如Linux只有5M多，windows也是5M多。在Docker里面可以设置使用Windows还是Linux系统，默认是用Linux系统，基于Ubuntu的，只有5M多。
4. 容器与镜像的关系类似于面向对象编程中的对象与类。
5. 仓库。Docker仓库的概念跟Git 类似，注册服务器也类似于GitHub 这样的托管服务

（2）流原

        Docker服务启动→下载镜像→启动该镜像得到一个容器→容器里运行着我们想要的程序;

​

​

Docker daemon（Docker守护进程）

        Docker daemon是一个运行在宿主机（DOCKER_HOST）的后台进程。我们可通过Docker客户端与之通信。

Client（Docker客户端）

        Docker客户端是Docker的用户界面，它可以接受用户命令和配置标识，并与Docker daemon通信。图中，docker build等都是Docker的相关命令。

Images（Docker镜像）

        Docker镜像是一个只读模板，它包含创建Docker容器的说明。

        和虚拟机中快照是类似的。在虚拟机中根据快照克隆一台虚拟机中。

        在Docker中根据Images创建容器。

Container（容器）

        容器是镜像的可运行实例。

        容器就相当于VMware中每一个克隆出来的虚拟机。但是容器要比虚拟机体积小很多。

Registry（仓库）

        Docker Registry是一个集中存储与分发镜像的服务。我们构建完Docker镜像后，就可在当前宿主机上运行。但如果想要在其他机器上运行这个镜像，我们就需要手动拷贝。此时，我们可借助Docker Registry来避免镜像的手动拷贝。

        一个Docker Registry可包含多个Docker仓库；每个仓库可包含多个镜像标签；每个标签对应一个Docker镜像。这跟Maven的仓库有点类似，如果把Docker Registry比作Maven仓库的话，那么Docker仓库就可理解为某jar包的路径，而镜像标签则可理解为jar包的版本号。

（3）实现技术

1. 基于linux的LXC
2. 基于谷歌的go语言开发

（4）具体：容器与虚拟机的区别

​

序号	特性	容器	虚拟机
1	流原	硬件资源划分	对进程进行封装隔离
2	同一台物理服务器	可以运行多个容器	可以运行多个虚拟机
3	启动	秒级	分钟级
4	占用硬盘空间	一般为几十MB	一般为10G
5	性能	接近原生	弱于原生
6	系统支持量	单机支持上千个容器	一般几十个
7	操作系统	与宿主机共享OS	宿主机上运OS
8	移植性	一次创建或配置， 可以在任意地方正常运行	差
9	占用系统资源	少	多

（5）具体：Docker守护态运行，-d 参数，查看控制台结果： docker logs tomcat1//(ID或Names)

（6）具体：Docker进入容器：docker exec -it 容器ID（Names）bash

1. docker exec -it tomcat1 bash //进入容器名称叫tomcat1
2. echo 'qfnj-weixin'>>index.jsp //对容器内的index.jsp进行字符串追加

 （7）具体：在宿主机和容器之间交换⽂件

1. 在宿主机和容器之间相互COPY⽂件 cp的⽤法如下：
   1. docker cp [OPTIONS] CONTAINER:PATH LOCALPATH //容器中 复制到 宿主机
   2. docker cp [OPTIONS] LOCALPATH|- CONTAINER:PATH //宿主机 复制到 容器中
2. 宿主机复制一个图片到容器中：将png图片复制到了容器指定目录下
   1. docker cp guoweixin.png tomcat2:/usr/local/tomcat/webapps/ROOT
3. 将容器内的index.jsp 复制出来，修改再复制回去
   1. docker cp tomcat2:/usr/local/tomcat/webapps/ROOT/index.jsp /root

（8）具体：Docker查看日志

1. Docker查看日志：
   1. docker logs 容器名称/ID
   2. docker logs -f -t --since="2018-12-1" --tail=10 qfjy_exam
      1. --since : 此参数指定了输出日志开始日期，即只输出指定日期之后的日志。 -f : 查看实时日志 -t : 查看日志产生 的日期 -tail=10 : 查看最后的10条日志 qfjy_exam :
   3. 容器名称docker logs -f --tail=10 容器名称

（9）具体：Docker数据卷

1. 数据卷
   1. 需求：
      1. 容器数据持久化
   2. 定义：
      1. 是一个可供一个或多个容器使用的特殊目录
   3. 特性：
      1. · 数据卷可以在容器之间共享和重用
      2. · 对数据卷的修改会立马生效
      3. · 对数据卷的更新，不会影响镜像
      4. · 数据卷默认会一直存在，即使容器被删除

5 只官配play：Docker环境搭建

1. 第一步：docker的版本选择
2. 第二步：docker的安装（安装、linux或windows版、连接外网）
   1. 官方提供的安装教程：
      https://docs.docker.com/install/linux/docker-ce/centos/#install-using-the-repository
      1. 下载docker-ce repo，为本地yum提供远程repo信息：curl https://download.docker.com/linux/centos/docker-ce.repo -o /etc/yum.repos.d/docker-ce.repo
      2. 安装依赖：yum install -y  https://download.docker.com/linux/fedora/30/x86_64/stable/Packages/containerd.io-1.2.6-3.3.fc30.x86_64.rpm
         yum localinstall containerd.io-1.2.6-3.3.fc30.x86_64.rpm
      3. 在线安装docker-ce：yum install -y docker-ce
      4. 本地安装docker-ce：
         yum intall -y libcgroup
         yum localinstall -y docker-ce-cli-19.03.12-3.el7.x86_64.rpm
         yum localinstall -y docker-ce-19.03.12-3.el7.x86_64.rpm
3. 第三步：docker的启动
   1. 启动命令：
      systemctl start docker
   2. 查看Docker状态：
      docker info

      结果如下：
      ​

4. 第四步：docker服务信息
5. 第五步：docker使用初体验
   1. 第1步：第一个docker容器
      1. 第a步：将docker服务启动。
      2. 第b步：Docker 镜像加速器，阿里云镜像加速器，下载一个镜像
         1. Docker运行一个容器前需要本地存在有对应的镜像：如果镜像不存在本地, Docker会从镜像仓库下载(默认是DockerHub公共注册服务器中的仓库https://hub.docker.com)。
         2. CentOS下怎么下载(pull) 镜像?
            1. 方式1：docker hub官网搜索要使用的镜像。
            2. 方式2：命令行使用命令搜索要使用的镜像：
               1. docker search tomcat进行搜索
               2. 下载镜像: docker pull tomcat
         3. CentOS下运行镜像：docker run tomcat 前台运行， 台运行， 加参数-d
         4. 显示本地已有的镜像：docker images ls
            1. REPOSITORY：来自于哪个仓库，比如docker.io/tomcat
            2. TAG：镜像的标记，比如latest
            3. IMAGE ID：镜像的ID号(唯一)
            4. CREATED：创建时间
            5. SIZE：镜像大小
      3. 第c步：启动下载下来的镜像得到一个容器
         1. docker run -d docker.io/tomcat或者docker run -d 41a54fe1f79d
         2. 默认是前台启动，如果需要后台启动，指定-d参数;
      4. 第d步：检查tomcat镜像是否启动容器成功;
         1. 通过ps -ef | grep tomcat查看
   2. 第2步：进入Docker容器
      1. 进入容器: docker exec -it cef0d139bfd6 bash
      2. i表示交互式的，也就是保持标准输入流打开;
      3. t表示虚拟控制台,分配到一个虚拟控制台;
      4. exit：退出容器。
   3. 第3步：客户机访问容器
      1. 从客户机上访问容器,需要有端口映射，docker容器默认采用桥接模
         式与宿主机通信，需要将宿主机的ip端口映射到容器的ip端口上;
   4. 第4步：停止容器: docker stop 容器ID/名称

6 只官配底play：Docker使用示例

（1）docker安装mysql

1. 下载mysql镜像：docker pull mysql:latest (安装的是 mysql 8.0)
2. 运行mysql镜像：docker run -p 3306:3306 -e MYSQL_DATABASE=workdb -e MYSQL_ROOT_PASSWORD=123456 xd mysql:latest
   1. 其中-e是指定环境变量
3. 进入容器：docker exec -it 3e8bf7392b4e bash
4. 登录mysql：mysql -u root -p
5. 修改密码：ALTERUSER 'root' @'localhost' IDENTIFIED BY '123456';
6. 授权远程登录访问：
   1. CREATE USER 'wkcto' @'%' IDENTIFIED WITH mysql_ native_ _password BY
      '123456';
   2. GRANT ALL PRIVILEGES ON *.* TO ' wkcto'@'%';

（2）docker安装nginx

1. 下载Nginx镜像：docker pull nginx
2. 运行Nginx镜像：docker run -d -p 80:80 nginx
3. 进入容器：docker exec -it 3e8bf7392b4e bash
4. 浏览器访问Nginx：http://192.168. 230.128:80
5. Nginx部署静态网站：
   1. 将linux的文件拷贝到docker容器某个目录下:
      1. docker cp /root/test.html bf8a58328e18:/usr/share/nginx/html

（3）Docker 安装Redis

（4）docker安装Zookepper

1. 下载Zookeeper镜像：docker pull zookeeper
2. 运行zookepper镜像：docker run -p 2181:2181 -d zookeeper
3. 进入容器：docker exec -it 3e8bf7392b4e bash
4. 客户端工具访问Zookeeper:

7 只官配底play：Docker镜像的自定义与发布

（1）认识Dockerfile文件

1. Dockerfile用于构建Docker镜像。Dockerfile 文件是由一行行命令语句组成，基于这些命令即可以构建一个镜像：
   1. 基础镜像信息;
   2. 维护者信息;
   3. 镜像操作指令;
   4. 容器启动时执行指令;
2. 如下图所示：Dockefile文件样例​
   1. from指令，第一条，多个镜像多个From指令
   2. MAINTAINER指令，维护者信息
   3. ENV指令，环境变量
   4. ADD指令，复制指定的<src>到容器中的<dest>;
   5. EXPOST指令，告诉服务容器暴露的端口号
   6. RUN指令，执行命令
   7. CMD指令 ，指定启动容器时执行的命令。

（2）Dockerfile自定义镜像

​

​

​

​

（3）镜像发布到仓库

1）阿里云容器镜像仓库

1. 网址: https://dev.aliyun.com

2）注册阿里云镜像仓库

1. 如果没有阿里云账号，需要注册一个阿里云账号;
2. 也可以使用淘宝账号、支付宝账号登录;

3）发布镜像阿里云镜像仓库

1. 登录阿里云镜像，进入管理中心，在自己我管理中心中，左侧点击镜像仓库菜单
   1. 登录阿里云Docker Registry
      docker login --username=hi35331710@ aliyun.com registry.cn-qingdao.aliyuncs.com
      ​
      用于登录的用户名为阿里云账号全名,密码为开通服务时设置的密码。
      您可以在产品控制台首页修改登录密码。
   2. 如果自己没有镜像仓库的话，需要创建一个镜像仓库; 
2. 对自己的镜像仓库点击管理链接;
3. 按照操作指南进行操作即可;
   ​
4. Docker hub镜像加速
   /etc/docker/daemon.json
   {" registry-mirrors": ["https://g3gwnry.mirror.aliyuncs.com"]}

8 只官配底play：Docker应用部署

（1）部署一个SpringBoot项目

1. 将开发的springboot程序打成jar包或者war包;
2. 将打好的jar包或war包上传到Linux某个目录下，比如:/root/docker 
3. 定义Dockerfile文件，用于创建项目镜像;
   1. Docker部署Jar包SpringBoot程序
      1. 定义Jar包程序Dockerfile文件
         FROM wkcto_jdk1.8.0_121
         MAINTAINER wkcto
         ADD springboot-web-1.0.0.jar /opt
         RUN chmod +x /opt/springboot-web-1.0.0.jar
         CMD java -jar /opt/springboot-web-1.0.0.jar
      2. 构建和运行Jar包程序的镜像：
         构建镜像: docker build -t springboot-web-jar .
         运行容器: docker run -d ac84bde53958
      3. Jar包程序依赖容器环境准备
         1. 运行Redis容器：docker run -p 6379:6379 -d redis
         2. 运行MySQL容器：docker run -p 3306:3306 -e MYSQL_ DATABASE=workdb -e
            MYSQL_ ROOT_ PASSWORD=123456 -d mysql:latest
         3. 修改容器保存: docker commit容器 id xxx(镜像名:tagxx)
            比如: docker commit b034f6d23833 wkcto .mysql_ new
      4. 运行Docker化的Jar包程序
         通过windows的浏览器访问,验证SpringBoot项目是否可以正常访问;
   2. Docker部署War包SpringBoot程序
      1. 定义War包程序Dockerfile文件
         FROM wkcto-tomcat-8.5.24
         MAINTAINER wkcto
         ADD springboot-web-1.0.0.war /usr/local/apache-tomcat-8.5.24/webapps
         EXPOSE 8080
         CMD /usr/local/apache-tomcat-8. 5.24/bin/catalina.sh run
      2. 构建和运行War包程序的镜像
              构建镜像: docker build -t springboot-web-war .
      3. War包程序依赖容器环境准备
             与上面部署Jar程序依赖的容器环境一样;
      4. 运行Docker化的War包程序
             通过windows的浏览器访问,验证SpringBoot项目是否可以正常访问;
             springboot-web-1.0.0.war. > springboot-web-1.0.0

五 docker

1 Docker的数据管理

        数据卷的作用是将宿主机的某个磁盘目录映射到容器的某个目录，从而实现宿主机和容器之间的数据共享。

2 Docker生命周期，即Docker容器生命周期

        

Docker的生命周期其实就是Docker容器从创建到被销毁的过程。

在课堂上使用过docker start和docker stop，图中的命令也是docker支持的命令。

（1）状态介绍

1）圆形

圆形代表的是稳定状态。

代表容器的五种状态：

created：初建状态

running：运行状态

stopped：停止状态

paused： 暂停状态

deleted：删除状态

2）长方形

代表容器在执行某种命令后进入的状态：状态是临时状态。

docker create ： 创建容器后，不立即启动运行，容器进入初建状态；

docker run ： 创建容器，并立即启动运行，进入运行状态；

docker start ： 容器转为运行状态；

docker stop ： 容器将转入停止状态；

docker kill ： 容器在故障（死机）时，执行kill（断电），容器转入停止状态，这种操作容易丢失数据，除非必要，否则不建议使用；

docker restart ： 重启容器，容器转入运行状态；

docker pause ： 容器进入暂停状态；

docker unpause ： 取消暂停状态，容器进入运行状态；

docker rm ： 删除容器，容器转入删除状态（如果没有保存相应的数据库，则状态不可见）。

3）菱形

需要根据实际情况选择的操作

killed by out-of-memory（因内存不足被终止）

宿主机内存被耗尽，也被称为OOM：非计划终止

这时需要杀死最吃内存的容器

然后进行选择操作

container process exitde（异常终止）

出现容器被终止后，将进入Should restart?选择操作：

yes 需要重启，容器执行start命令，转为运行状态。

no 不需要重启，容器转为停止状态。

六 镜像

1 Docker File管理(如何自定义镜像)

七 容器

八 仓库

1 阿里云镜像仓库

（1）低内存空间开启swap(阿里云)

1. 内存过小docker可能会出现exited(137)错误，随机关闭某个容器，我这mysql被关了好几次。这实际上是os关的，并非docker。可以建立swap交换空间。

2 本地镜像仓库

3 Harbor介绍及实践

1. docker 官方提供的私有仓库 registry，用起来虽然简单 ，但在管理的功能上存在不足。

九 工具 

1 idea集成docker

（1）Idea集成docker实现镜像打包一键部署

1. Docker开启远程访问
2. IDEA安装Docker插件
3. IDEA配置docker
4. docker-maven-plugin
5. 执行命令
6. idea操作docker
7. 扩展配置
    

（2）Idea整合Docker CA加密认证

1. Docker认证命令配置
2. idea操作docker

2 docker图形化工具：Portainer

3 应用程序工具：Docker Compose

十 持续集成与持续交付

1 CICD - 持续集成与持续交付

2 基于Docker+Jenkins+Gitlab搭建持续集成环境

（1）搭建GitLab服务器

（2）Jenkins安装

（3）Jenkins连接GitLab服务器

（4）Jenkins免密钥登录GitLab

（5）Jenkins配置JDK和MAVEN

（6）测试

（7）实战测试 持续交付和持续部署