docker学习笔记

Docker基础：

Docker简介：

1. 它允许开发者打包它们的依赖包和应用到一个轻量级、可移植的容器中，可实现虚拟或移植到任何一个流行的liunx系统上。

2. 容器性能开销极低。

3. docker能使“应用程序”和“基础架构”分开，从而快速交付软件。通过利用docker的方法来快速交付、测试、部署代码。

   3.1 快速交付：使用docker将其应用程序推送到测试环境中，当发现程序错误时，可以在开发环境中对其进行修复，之后将其重新部署到测试环境中，并进行测试和验证。测试完成后，将修补程序推送给生产环境，就像将更新的镜像推送到生产环境中一样简单。

   3.2 docker是基于容器的平台，允许高度可移植的工作负载（既可在开发人员的本机上，数据中心的物理或虚拟机、云服务或混合环境中运行）。

   3.3 docker非常适合于高密度环境以及中小型部署，即可以用更少的资源做更多的事情。

Docker是什么？

Docker打破传统的【程序即应用】的观念，通过【镜像image】将作业系统核心除外，运作应用程序所需要的系统环境，由下而上打包，达到应用程序跨平台间的无缝接轨运行。

Docker是基于go语言实现的云开源项目。

通过将应用打包为镜像（一次镜像，处处运行），并运行在docker（docker容器在任何操作系统上都是一致的）上，从而实现跨平台、跨服务器运行。只需一次配置好环境，之后即可一键部署。

总结：解决了运行环境和配置问题的软件容器，方便做持续集成，并有助于整体发布的容器虚拟化技术。

容器与虚拟机的比较：

容器的演变过程：

传统虚拟机技术：

基于安装在主操作系统上的虚拟化管理系统（如VirtualBox、vmware等），创建虚拟机（虚拟化出各种硬件），在虚拟机上安装从操作系统，之后可安装部署各种应用。

缺点：启动慢、占用资源多、冗余步骤多。

docker虚拟化技术：

linux容器，不是模拟一个完整的操作系统，而是对进程进行隔离。通过将软件运行所需资源打包到一个隔离的容器中，便可在任何环境中运行。

Docker容器，是在操作系统之上实现虚拟化，直接复用本地主机的操作系统（传统虚拟机则是在硬件层面实现虚拟化，故docker启动更快、占用体积更小）。

Docker与传统虚拟机技术的不同之处：

1. 传统的虚拟机技术，是虚拟出一套硬件后，在其上运行一个完整的操作系统，在该系统上再运行所需应用程序。
2. 容器内的应用程序，直接运行在宿主的内核，其并没有自己的内核且没有进行硬件虚拟，故容器相比传统虚拟机更轻便。
3. 容器之间相互隔离，且有自己的文件系统，即容器之间并不会相互影响且能区分计算资源。

Docker为何比VM虚拟机更快？

1. docker有着比虚拟机更少的抽象。

   docker不需要hypervisor（虚拟机）实现硬件资源虚拟化，运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此，CPU、内存利用率会大大提升。

2. docker利用的是宿主机的内核，而不需要加载操作系统OS内核。

   新建一个docker不需要和虚拟机一样重新加载一个操作系统内核，而是直接利用宿主机的操作系统，省去了费时费资源的引导、加载、返回内核的过程，故创建一个docker容器只需几秒钟。
   

作用：

一次构建，随处运行。

1. 更快速的应用交付和部署：Docker化后，只需要交付少量容器镜像文件（应用安装配置在镜像里已经内置好），在正式生产环境加载镜像并运行即可，大大节省部署配置和测试验证时间。

2. 更便捷的升级和扩缩容：每个Docker容器将变成一块“积木”，当现有的容器不足以支撑业务处理时，可通过镜像运行新的容器进行快速扩容。

3. 更简单的系统运维：应用容器化运行后，容器会将应用程序相关的环境和状态完全封装起来。当出现程序异常时，也可以通过测试环境的相同容器进行快速定位和修复。

4. 更高效的计算资源利用：Docker是内核级虚拟化（不像传统的虚拟化技术一样需要额外的Hypervisor支持），在一台物理机上可以运行很多个容器实例，故大大提升了物理服务器的CPU和内存的利用率。

Docker的架构：

三个基本概念：

1. 镜像image：是一个只读模版。相当于一个root文件系统。

2. 容器container：镜像是静态的定义，而容器则是镜像运行时的实体（类似面向对象中，类与对象的关系），即docker容器通过docker镜像来创建，一个镜像可创建多个容器。

   2.1 docker容器使用C/S架构，使用远程API来管理和创建docker容器。

   2.2 docker利用容器运行一个/一组应用，容器就类似一个虚拟化的运行环境，为镜像提供一个标准和隔离的运行环境。

   2.3 容器可被创建、启动、停止、删除、暂停等。

   2.4 容器可看做一个简易版的 Linux 环境（包括root用户权限、进程空间、用户空间和网络空间等）和运行在其中的应用程序。

3. 仓库repository：仓库可看作一个代码控制中心，用来保存镜像文件。

   3.1 类似于Maven仓库（存放各种jar包的地方）、github仓库（存放各种git项目的地方）、Docker公司提供的官方registry被称为Docker Hub（存放各种镜像模板的地方）。

   3.2 仓库分为公开仓库（Public）和私有仓库（Private）两种形式。

   3.3 最大的公开仓库是 Docker Hub，存放了数量庞大的镜像供用户下载。

总结：Docker 本身是一个容器运行载体或称之为管理引擎。通过将应用程序和配置依赖打包好形成一个可交付的运行环境，即image镜像文件。Docker 根据 image 文件生成容器的实例。同一个 image 文件，可以生成多个同时运行的容器实例。

Docker平台架构图：

Docker基于C/S架构，守护进程运行在主机上，之后通过socket连接从客户端的访问，守护进程从客户端接受命令并管理运行在主机上的容器。

Docker的运行流程：

1. 用户使用docker client与docker daemon建立通信，并发送请求给后者。
2. docker daemon作为docker架构中的主体部分，首先提供docker server的功能使其可以接受docker client的请求。
3. docker engine执行docker内部的一系列工作（每项工作都以job的形式存在）。
4. job在运行过程中，当需要容器镜像时，则从docker registry中下载，并通过镜像管理驱动graph driver将下载镜像以graph的形式存储。
5. 当需要为docker创建网络环境时，通过网络管理驱动Network driver创建并配置docker容器网络环境。
6. 当需要限制docker容器运行资源或执行用户指令等操作时，则通过execdriver来完成。
7. libcontainer是一项独立的容器管理包，network driver、exec driver都是通过libcontainer来实现具体对容器的操作。

安装与配置：

前提说明：

Docker非通用的容器工具，需要依赖已存在并运行的linux内核环境。

Docker本质上是在已经运行的linux下制造了一个隔离的文件环境，执行效率与linux主机几乎等同。

centos7上的安装步骤：

1. yum安装gcc相关：sudo yum -y install gcc、sudo yum -y install gcc-c++

2. 安装需要的软件包：sudo yum install -y yum-utils

3. 设置stable的镜像仓库：sudo yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

4. 更新yum软件包索引：sudo yum makecache fast

5. 安装docker ce：sudo yum -y install docker-ce docker-ce-cli containerd.io

6. 启动docker：systemctl start docker

   ps -ef | grep docker：查看dockerd进程

7. 测试：

   docker version：查看Client、Server的版本信息

   docker run hello-world：执行流程如下：

8. 卸载：

   8.1 停止docker守护进程：systemctl stop docker

   8.2 删除安装包：yum remove docker-ce docker-ce-cli containerd.io

   8.3 删除镜像、容器、配置文件等内容：rm -rf /var/lib/docker、rm -rf /var/lib/containerd

Docker常用命令：

帮助启动类命令：

1. 启动docker：systemctl start docker
2. 停止docker：systemctl stop docker
3. 重启docker：systemctl restart docker
4. 查看docker状态：systemctl status docker
5. 设置开机启动docker：systemctl enable docker
6. 查看docker概要信息：docker info
7. 查看docker总体帮助文档：docker --help
8. 查看docker命令帮助文档：docker 具体命令 --help

镜像命令：

1. 查看本地镜像：

   docker images [options]

   -a：列出所有本地镜像（含历史映像层）

   -q：只显示镜像ID

2. 搜索镜像：（网站https://hub.docker.com）

   docker search [options] 镜像名字

   options说明：--limit N表示只列出N个镜像（默认为25个）。

3. 下载/拉取镜像到本地：

   docker pull 镜像名字[:tag]

   补充：没有tag就是最新版，等价于docker pull 镜像名字:latest

4. 查看镜像/容器/数据卷所占用的空间：

   docker system df

5. 删除镜像：

   删除单个镜像：docker rmi 镜像ID

   删除多个镜像：docker rmi -f 镜像名1:tag 镜像名2:tag

   删除全部镜像（慎用）：docker rmi -f $(docker images -qa)

容器命令：

有镜像才能创建命令。

1. 新建和重启容器：

   docker run [options] image [command] [arg...]

   options说明：

   1.1 --name="容器新名字"：为容器指定一个名称。

   1.2 -d：后台运行容器并返回容器ID，也即启动守护式容器（后台运行）。例：docker run -d 容器名。

   1.3 -it：以交互模式运行容器，并为容器重新分配一个伪输入终端，即启动交互式容器。举例：docker run -it centos:latest /bin/bash。

   1.4 -P：随机端口映射

   1.5 -p：指定端口映射

   

2. 列出当前所有正在运行的容器： docker ps [options]

   options说明：

   2.1 -a：列出当前所有正在运行的+历史上运行过的容器

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

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

   2.4 -q：静默模式，只显示容器编号

3. 退出容器：

   3.1 exit：停止容器

   3.2 ctrl + p + q：退出，但容器并不停止

4. 启动已停止运行的容器/重启容器：

   docker start/restart 容器ID/容器名

5. 停止/强制停止容器：

   docker stop/kill 容器ID/容器名

6. 删除已停止的容器：

   docker rm 容器ID或docker rm -f $(docker ps -a -q)

7. 查看容器日志：

   docker logs 容器ID

8. 查看容器内运行的进程：

   docker top 容器ID

9. 查看容器内部细节：

   docker inspect 容器ID

10. 进入正在运行的容器并以命令行交互：

    docker exec -it 容器ID /bin/bash（bashShell）或docker attach 容器ID

    上述两者的区别：

    10.1 attach直接进入容器启动命令的终端，不会启动新的进程，用exit退出会导致容器的停止；

    10.2 exec是在容器中打开新的终端，并且可以启动新的进程，用exit退出不会导致容器的停止。

    注意：一般用-d后台启动程序，再用exec进入对应容器实例。

11. 从容器内拷贝文件到主机上

    docker cp 容器ID:容器内路径 目的主机路径

12. 导入和导出容器：

    导出容器：docker export 容器ID > 文件名.tar.gz

    导入容器：cat 文件名.tar.gz ｜ docker import - 镜像用户/镜像名:镜像版本号

常见命令总结：

attach：Attach to a running container

build：Build an image from a Dockerfile

commit：Create a new image from a container changes

cp：Copy files/folders from the containers filesystem to the host path

create：Create a new container

diff：Inspect changes on a container’s filesystem

events：Get real time events from the server

exec：Run a command in an existing container

export：Stream the contents of a container as a tar archive

import：Create a new filesystem image from the contents of a tarball

save：Save an image to a tar archive

history：Show the history of an image

images：List images

ps：List containers

info：Display system-wide information

inspect：Return low-level information on a container

kill：Kill a running container

restart：Restart a running container

start：Start a stopped containers

stop：Stop a running containers

pause：Pause all processes within a container

load：Load an image from a tar archive

login：Register or Login to the docker registry server

logout：Log out from a Docker registry server

logs：Fetch the logs of a container

port：Lookup the public-facing port which is NAT-ed to PRIVATE_PORT # 查看映射端口对应的容器内部源端口

pull：Pull an image or a repository from the docker registry server

push：Push an image or a repository to the docker registry server

rm：Remove one or more containers

rmi：Remove one or more images # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]

run：Run a command in a new container

search：Search for an image on the Docker Hub

tag：Tag an image into a repository

top：Lookup the running processes of a container

unpause：Unpause a paused container

version：Show the docker version information

wait：Block until a container stops, then print its exit code

docker stats：Real-time view of all the containers on the host CPU, memory, network traffic

Docker镜像：

镜像加速器配置：

1. 登陆阿里云开发者平台/点击控制台/选择容器镜像服务/获取加速器地址：

   https://g3zluynm.mirror.aliyuncs.com

2. 修改daemon配置文件/etc/docker/daemon.json

   sudo mkdir -p /etc/docker/

   vim /etc/docker/daemon.json

   添加内容：{"registry-mirrors":["https://g3zluynm.mirror.aliyuncs.com"]}

3. 重启服务器：systemctl daemon-reload、systemctl restart docker

镜像：

一种轻量级、可执行的独立软件包。通过将应用程序、配置依赖打包，形成一个可交付的运行环境（包括代码、运行时需要的库、环境变量和配置文件等），称为image镜像文件。

注：只有通过该镜像文件，才能生成docker实例。

UnionFS联合文件系统：

UnionFS是一种分层、轻量级且高性能的文件系统，支持对文件系统的修改作为一次提交来层层叠加。同时可将不同目录挂载到同一个虚拟文件系统下。

UnionFS是docker镜像的基础。

镜像可以通过分层来继承，基于基础镜像（无父镜像），可制作各种具体的应用镜像。

特性：一次同时加载多个文件系统，但从外面看，只能看到一个文件系统。联合加载会将各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录。

docker镜像加载原理：

docker的镜像，实际上是由一层层文件系统组成，即联合层级文件系统UnionFS。

1. bootfs：主要由bootloader和kernel组成，引导文件系统。

   linux刚启动时，会加载docker镜像最底层的bootfs引导文件系统。bootloader加载完成后，整个内核都会处于内存中，此时内存使用权由bootfs转交给内核，系统之后会卸载掉bootfs。

2. rootfs：包含典型的linux系统的/dev、/proc、/bin、/etc等标准目录和文件，即各种不同的操作系统的发行版：ubuntu、centos等。

   注：docker中的centos只有200M，因其直接使用host的kernel（不同linux发行版共用bootfs），只有很小的rootfs（只需包含最基本的命令、工具和程序库即可）。

镜像分层结构优点：

最大的优点：共享资源，方便复制迁移，就是为了复用。

镜像的每层都可以被共享。

举例：如果多个镜像都从相同的base镜像构建而来，那么docker host只需在磁盘上保存一份base镜像，同时内存中也只需加载一份base镜像，就可以为所有容器服务。

镜像只读，容器层可写：

docker镜像层都是只读的，容器层是可写的。

当容器启动时，一个新的可写层被加载到镜像的顶部，通常被称为“容器层”，之下均为“镜像层”。

docker中的镜像分层，支持通过扩展现有镜像，创建新的镜像。新镜像是从base镜像一层层叠加生成的，每安装的一个软件就在现有镜像基础上增加一层。

docker镜像commit操作实例：

docker commit提交容器副本，使之成为一个新的镜像。

docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

举例：

1. 从docker hub上，拉取centos:7的镜像：docker pull centos:7
2. 使用centos:7镜像，新建并启动交互式的容器：docker run -it centos:7 /bin/bash
3. 安装vim：sudo yum install vim
4. commit新镜像：docker commit -m="add vim ok" -a="sunguangyuan" bbcba66b61a7 mycentos:7
5. 使用mycentos:7镜像，新建并启动交互式的容器：docker run -it mycentos:7 /bin/bash

本地镜像发布到公有/私有库：

本地镜像发布到阿里云或私有库过程：

docker registry是官方提供的工具，可用于构建私有镜像仓库。

1. 下拉镜像Docker Registry：docker pull registry

2. 运行私有库registry，相当于本地有个私有docker hub：

   docker run -d -p 5000:5000 -v /tmp/myregistry/:/tmp/registry --privileged=true registry

3. curl验证私服库上有什么镜像：

   curl -XGET http://宿主机IP:IP/v2/_catalog

   ​ 本人虚拟机为：curl -XGET http://192.168.10.5:5000/v2/_catalog

4. 将新镜像mycentos:7修改为符合私服规范的tag：

   docker tag image:tag hostIP:port/repository:tag

   ​ 本人虚拟机为：docker tag mycentos:7 192.168.10.5:5000/mycentos:7

5. 修改配置文件使之支持http（在vim /etc/docker/daemon.json文件中，添加主机ip和port）：

   {"registry-mirrors": ["https://g3zluynm.mirror.aliyuncs.com"], "insecure-registries":["192.168.10.5:5000"]}

6. push推送到私服库：

   docker push hostIP:port/mycentos:7

   ​ 本人虚拟机为：docker push 192.168.10.5:5000/mycentos:7

7. 再次curl验证私服库上的镜像

   curl -XGET http://宿主机IP:IP/v2/_catalog

   ​ 本人虚拟机为：curl -XGET http://192.168.10.5:5000/v2/_catalog

8. 删除原有本地的docker镜像：

   docker rmi -f 192.168.10.5:5000/mycentos:7

   docker rmi -f mycentos:7

9. pull该镜像到本地，并运行：

   docker pull hostIP:port/mycentos:7

   ​ 本人虚拟机为：docker pull 192.168.10.5:5000/mycentos:7

   docker run -it 镜像ID /bin/bash

Docker容器数据卷：

引入：

卷就是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但不属于联合文件系统，故能够绕过unionFS提供一些持续存储或共享数据的特性。

dokcer容器产生的数据，如果不备份，那么当容器实例删除后，容器内的数据也会丢失。

卷设计的目的：

数据的持久化，完全独立于容器的生存周期，故docker不会在容器删除时，删除其挂载的数据卷。会将docker容器内的数据，保存进宿主机的磁盘中。

特点：

1. 数据卷可在容器之间共享或重用数据
2. 卷中的更改，可直接实时生效
3. 数据卷中的更改不会包含在镜像的更新中
4. 数据卷的生命周期，一直持续到没有容器使用为止

使用：

宿主机vs容器之间的映射添加容器卷：

1. 运行一个带有容器卷存储功能的容器实例：（容器该目录下的内容 <“双向互通”> 宿主机绝对路径目录下的内容，目的（映射）：将容器内的数据备份+持久化到本地主机目录）

   docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录 镜像名:tag

2. 查看数据卷是否配置成功：

   docker inspect 容器ID

   "Mounts": [
       {
           "Type": "bind",
           
           # source：宿主机的绝对路径，destination：docker中容器内的目录 
           "Source": "/tmp/docker_mycentos7_tmp_data",
           "Destination": "/tmp/docker_host_data",
           
           "Mode": "",
           "RW": true,
           "Propagation": "rprivate"
       }
   ],
   

   注意：

   1. docker中容器某个目录下内容更改，宿主机会同步获得。
   2. 宿主机修改，docker容器会同步获得（即使docker容器中途停止工作，重启后，仍然看到同步的内容）。

读写规则映射添加说明：

1. （默认为）可读写rw：

   docker run -it --privilieged=true -v /宿主机绝对路径目录:/容器内目录:rw 镜像名:tag

2. 只读ro：（容器内部被限制，只能读取不能写；但宿主机写入内容，可以同步到容器内，容器可以读取到）

   docker run -it --privilieged=true -v /宿主机绝对路径目录:/容器内目录:ro 镜像名:tag

卷的继承和共享：

docker run -it --privileged=true --volumes-from 父类镜像的别名或ID --name 镜像别名 镜像名:ID

Docker镜像常规安装简介：

1. 搜索镜像：docker search 镜像名

2. 拉取镜像：docker pull 镜像名

3. 查看镜像：docker images

4. 启动镜像，即创建容器实例：docker run（使用docker ps查看容器是否启动成功）

   -i：交互、-t：终端、-d：后台、-p 宿主机端口:docker容器端口、-P：随机分配端口

   注意：一般都是在后台通过镜像创建容器实例，之后执行该命令后docker exec -it 容器ID /bin/bash，可再进入容器操作。

5. 停止容器

6. 移除容器

mysql的安装：

1. 宿主机的3307端口映射到容器的3306端口，

   --privileged=true ：容器内root拥有真正root权限，否则容器内root只是外部普通用户权限，

   -v：创建容器卷：宿主机的目录和容器的目录完成“映射”，

   -e=MYSQL_ROOT_PASSWORD：设置密码，--name：容器重命名

   docker run -d -p 3307:3306 --privileged=true 
   -v /sunguangyuan/mysql/log:/var/log/mysql 
   -v /sunguangyuan/mysql/data:/var/lib/mysql 
   -v /sunguangyuan/mysql/conf:/etc/mysql/conf.d 
   -e=MYSQL_ROOT_PASSWORD=123456
   --name mysql 
   mysql:5.7
   

2. 在宿主机新建my.cnf文件，并修改配置（会映射进容器中）：

   [client]
   default_character_set=utf8
   [mysqld]
   collation_server = utf8_general_ci
   character_set_server = utf8
   

3. 重启mysql容器并重新查看字符编码：

   docker restart mysql

   show variables like '%character%'

4. 因在宿主机上有mysql的容器卷，故即使该docker重启mysql容器，重启后原有数据仍然存在；

安装redis、安装nginx，可参考mysql的安装过程。

Docker进阶：

DockerFile解析：

介绍：

DockcerFile是用类似构建docker镜像的文本文件，是一条条构建镜像所需的指令和参数构成的脚本。

构建的流程：编写dockerfile文件 --> docker build命令构建镜像 --> docker run依镜像运行实例。

内容的基础知识：

1. 每个保留字指令必须大写，且其后至少一个参数；
2. 指令按照从上到下的顺序执行；
3. #表示注释；
4. 每执行一条指令，都会创建一个新的镜像层，并对镜像层进行提交。为了防止出现过多无意义的层，造成镜像膨胀过大的问题，可尽可能地合并指令。

执行DockerFile的大致流程：

1. docker从基础镜像运行一个容器；
2. 执行一条指令，并对容器进行修改；
3. 执行类似的docker commit的操作，提交一个新的镜像层；
4. docker再基于刚提交的镜像运行一个新容器；
5. 执行dockerfile中的下一条指令，直到所有指令都执行完成；

DockerFile、Docker镜像、Docker容器三者的关系：

从应用软件角度看，DockerFile（面向开发）、Docker镜像（交付标准）、Docker容器（部署、运维）三者分别代表软件的三个不同阶段，三者合力构成了Docker的体系的基石。

• DockerFile是软件的原料；
• Docker镜像是软件的交付品；
• Docker容器，则是软件镜像的运行态，即依照镜像运行的容器实例；

1. DockerFile定义了进程需要的一切东西，包括执行代码或文件、环境变量、依赖包、运行时环境、动态链接库、操作系统发行版、服务进程、内核进程（当应用进程需要与系统服务和内核进程打交道时，则需要考虑如何设计namespace的权限控制等）。
2. 在用DockerFile定义一个文件之后，docker build时会产生一个Docker镜像。运行Docker镜像时，真正开始提供服务。
3. Docker容器，是直接提供服务的。

常用的保留字指令：

FROM：基础镜像，指定一个已存在的镜像作为模板。（dockerfile的第一条指令）

MAINTAINER：镜像维护者的姓名和邮箱地址。

ADD：将宿主机目录下的文件拷贝进镜像，会自动处理url和解压tar压缩包。

COPY：类似于ADD，拷贝文件和目录到镜像中。将从构建上下文目录中<源路径>的文件/目录，复制到新的一层的镜像内的<目标路径>位置。COPY ["src", "dest"]，注意：目标路径不存在则会自动创建。

RUN：容器构建docker build时，需要运行的命令。两种格式：

• shell格式：RUN 命令行命令
• exec格式：RUN ["可执行文件","参数1","参数2"]。

---

WORKDIR：指定在创建容器后，终端默认登录进来的工作目录，即登陆后的落脚点。

USER：指定该镜像以何种用户执行，默认为root用户。

---

ENV：用来在构建镜像过程中，设置环境变量。可在后续的RUN指令/其他指令中，直接使用这些环境变量。ENV MYPATH /usr/local/***、WORKDIR $MYPATH。

EXPOSE：当前容器对外暴露出的端口。

VOLUME：容器数据卷，用于数据保存和持久化工作。

CMD：指定容器启动后要干的事，在docker run时执行。当dockerfile中有多个CMD命令时，只有最后一个生效，CMD会被docker run之后的参数替换。

ENTRYPOINT：也是用来指定一个容器启动时，要运行的命令。类似于CMD指令，但ENTRYPOINT不会被docker run后的命令覆盖，这些命令行参数，会被当作参数送给ENTRYPOINT指令指定的程序。

• 命令格式：ENTRYPOINT ["<executable>","<param1>","<param2>",...]
• ENTRYPOINT和CMD可以一起使用，但指定ENTRYPOINT后，CMD的含义会发生变化，是将CMD的内容作为参数传递给ENTRYPOINT指令，即<ENTRYPOINT>"<CMD>"。
• docker run时，可指定ENTRYPOINT运行所需的参数。
• 注意：多个ENTRYPOINT同时存在时，仅最后一个有效。

举例：

自定义镜像mycentosjava8：

1. 要求：centos7镜像 + vim + ifconfig + jdk8。

2. 编写：将Dockerfile文件和JDK8的压缩包，放在同一目录下。
   

   # Dockerfile的文件内容，需要在父镜像centos7上，安装vim+ifconfig+jdk8
   FROM centos:7
   MAINTAINER sunguangyuan<xdsungy@126.com>
    
   ENV MYPATH /usr/local
   WORKDIR $MYPATH
    
   #安装vim编辑器
   RUN yum -y install vim
   #安装ifconfig命令查看网络IP
   RUN yum -y install net-tools
   #安装java8及lib库
   RUN yum -y install glibc.i686
   RUN mkdir /usr/local/java
   #ADD 是相对路径jar,把jdk-8u152-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
   ADD jdk-8u152-linux-x64.tar.gz /usr/local/java/
   #配置java环境变量
   ENV JAVA_HOME /usr/local/java/jdk1.8.0_152
   ENV JRE_HOME $JAVA_HOME/jre
   ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
   ENV PATH $JAVA_HOME/bin:$PATH
    
   EXPOSE 80
    
   CMD echo $MYPATH
   CMD echo "success--------------ok"
   CMD /bin/bash
   

3. 构建镜像：docker build -t 新镜像名:tag .

   docker build -t mycentosjava8:1.5 .

4. 查看镜像是否构建成功：docker images

5. 运行该镜像：docker run -it 新镜像名:tag

虚悬镜像：

仓库名、标签都是<none>的镜像，俗称为虚悬挂镜像dangling image。

通过Dockerfile生成一个虚悬镜像/删除一个虚悬镜像：

1. vim Dockerfile：

   FROM centos:7
   CMD echo 'action is success'
   

2. docker build .

3. 查看虚悬镜像：docker iamge ls -f dangling=true

4. 删除所有的虚悬镜像：docker image prune。

Docker网络：

介绍：

1. docker网络不启动时，默认的网络情况。

2. docker启动后的网络情况：

常用的网络命令：

1. 查看docker网络模式命令：docker network ls
2. 查看网络数据源数据：docker network inspect ***网络名字
3. 删除网络：docker network rm ***网络名字

作用：

1. 容器间的互联和通信、端口映射；
2. 容器IP变动时，可通过服务名直接网络通信而不受影响；

网络模式：

总体介绍：

1. bridge模式：使用--network bridge指定（默认使用docker0）；
2. host模式：使用--network host指定
3. none模式：使用--network none指定
4. container模式：使用--network container:NAME/容器ID指定

容器实例内默认网络IP生产规则：

说明：

1. 先启动两个centos实例：
   

2. docker inspect 容器名/容器ID

3. 关闭centos1实例，查看ip变化：
   

结论：

docker容器内部的IP可能会发生改变。

docker network_bridge：

Docker服务默认会创建一个docker0网桥（其上有一个docker0内部接口），在内核中连通了其他物理/虚拟网卡，所有容器和本地主机都放在同一个物理网络。

Docker默认指定了docker0接口的IP地址和子网掩码，让主机和容器之间可以通过网桥相互通信。

查看bridge网络的详细信息，并通过grep获取名称项：docker network inspect bridge | grep name。

详细说明：

1. Docker使用linux桥接，在宿主机虚拟一个Docker容器网桥docker0，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，成为Container IP。同时，Docker网桥是每个容器的默认网关。同一个宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container IP直接通信。
2. docker run时，默认使用的网桥模式就是bridge。
3. 整个宿主机的网桥模式都是docker0，在本地主机和容器内创建一对对等虚拟设备接口<veth, eth0>，这一对接口叫veth pair，并让它们彼此接通；
4. 将宿主机上的所有容器都接到这个内部网络上，两个容器在同一个网络上，会从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的。

两两匹配的验证：

docker network_host：

直接使用宿主机的IP地址与外界进行通信，不再需要额外进行NAT转换。

容器不会获得一个独立的Network Namespace，而是与宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡，而是使用宿主机的IP和端口。

容器共享宿主机网络IP，好处：外部主机与容器可以直接通信。

docker network_none：

Docker容器没有网卡、IP、路由等信息，只有lo标识，即127.0.0.1本地回环地址。需要自己为Docker容器添加网卡、配置IP等。

docker network_container：

新建的容器与已存在的一个容器共享网络ip配置（而非与宿主机共享）。新创建的容器（不会创建自己的网卡，配置自己的IP），与一个指定的容器共享IP、端口范围等。

两个容器除了网络方面外，其他的如文件系统、进程列表均是隔离的。

分别启动alpine1和alpine2容器，且容器alpine2共享容器alpine1的网络ip配置。当前关闭容器alpine1后，容器alpine2的容器网络配置也会消失。

自定义网络：

使用默认的bridge网络模式：

tomcat安装iproute2，用于ip addr指令的使用：

apt update 
apt install iproute2

tomcat安装iputils-ping，用来ping ***IP***指令的使用

apt install iputils-ping

使用自定义的bridge网络模式：

docker network create sgy_bri_network

docker network ls

结论：

自定网络本身就维护好了主机名和ip的对应关系，即ping ip或域名都能通。

Docker-compose容器编排：

介绍：

Docker-Compose是 Docker 官方的开源项目，可以管理多个 Docker 容器组成一个应用，负责实现对 Docker 容器集群的快速编排。

作用：

Docker建议每一个容器中只运行一个服务，因为docker容器本身占用资源极少，所以最好是将每个服务单独的分割开，但实际一个微服务项目需要包含多个服务容器，则需要如何管理这些容器？

Compose 则允许用户用一个单独的 docker-compose.yml 文件，写好多个容器之间的调用关系。

综上，通过用一个配置文件定义一个多容器的应用，然后使用一条指令安装这个应用的所有依赖，完成构建。Docker-Compose 解决了容器与容器之间如何管理编排的问题。

安装/卸载配置：

# 安装步骤：
curl 
-L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" 
-o /usr/local/bin/docker-compose

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

docker-compose --version

# 卸载步骤：
sudo rm /usr/local/bin/docker-compose

核心概念：

1. 一个文件：docker-compose.yml
2. 两个要素：服务、工程。
   • 服务：一个个应用容器实例，如订单微服务、库存微服务、mysql微服务、redis微服务、nginx微服务等。
   • 工程：由一组关联的应用容器组成的一个完整业务单元，在docker-compose.yml文件中定义。

使用步骤：

1. 编写dockerfile定义各个微服务应用，并构建出对应的镜像文件；
2. 使用docker-compose.yml定义一个完整业务单元，安排好整体应用中各个容器服务;
3. 执行docker-compose up命令，启动并运行整个应用程序，完成一键部署上线。

Compose常用命令：

1. 查看帮助：docker-compose -h

2. 启动所有docker-compose服务：docker-compose up

   启动所有docker-compose服务并后台运行：docker-compose up -d

3. 停止并删除容器、网络、卷、镜像：docker-compose down

4. 进入容器实例内部：docker-compose exec docker-compose.yml文件中写的服务id /bin/bash

5. 展示当前docker-compose编排过的运行的所有容器：docker-compose ps

6. 展示当前docker-compose编排过的容器进程：docker-compose top

7. 查看容器输出日志：docker-compose logs yml里面的服务id

8. 检查配置：docker-compose config

   检查配置有问题才有输出：docker-compose config -q

9. 重启/启动/停止服务：docker-compose restart/start/stop