学习目标：

• 掌握Docker能理解基础知识Docker镜像和容器的概念
• 完成Docker安装与启动
• 掌握Docker与容器相关的镜像命令
• 掌握Tomcat Nginx 安装软件的常用应用
• 掌握docker迁移和备份相关命令
• 能够运用Dockerfile编写创建镜像的脚本
• 可建造和使用docker私有仓库
• 可部署微服务项目

虚拟化(英语:Virtualization）它是一种资源管理技术，是抽象和转换计算机的各种实体资源，如服务器、网络、内存和存储，打破实体结构之间不可切割的障碍，使用户能够更好地应用这些资源。这些资源的新虚拟部分不受现有资源的架设、区域或物理组态的限制。虚拟化资源一般包括计算能力和数据存储。

在实际生产环境中，虚拟化技术主要用于解决高性能物理硬件产能过剩和旧硬件产能过低的重组和重用，最大限度地利用物理硬件 充分利用资源

虚拟化技术有很多种，如软件虚拟化、硬件虚拟化、内存虚拟化、网络虚拟化(vip)、桌面虚拟化、服务虚拟化、虚拟机等。

下图下图 Docker 与传统的虚拟化方法不同，可以看出容器是在操作系统层面实现虚拟化，直接重用本地主机的操作系统，而传统的方法是在硬件层面实现。 与传统虚拟机相比，Docker其优点是启动速度快，占用体积小。

Docker 它诞生于开源项目 2013 年初，最初是 dotCloud 基于公司内部的业余项目。 Google 公司推出的 Go 语言实现。 项目后来加入 Linux 基金会，服从 Apache 2.0 协议，项目代码在 GitHub 上进行维护。

Docker 自开源以来，它受到了广泛的关注和讨论，以至于 dotCloud 公司后来改名 Docker Inc。Redhat 已经在其 RHEL6.5 中集中支持 Docker；Google 也在其 PaaS 广泛应用于产品中。

Docker 项目的目标是实现轻量级操作系统的虚拟化解决方案。 Docker 的基础是 Linux 容器（LXC）等技术。

在 LXC 的基础上 Docker 进一步包装，使用户不需要关心容器管理，使操作更加简单。用户操作 Docker 容器和操作快速轻量级虚拟机一样简单。

为什么选择Docker?

(1)上手快。

用户只需几分钟就可以使用自己的程序Docker化”。Docker依靠写时复制（copy-on-write）模型，使修改应用程序也很快，可以说达到了随心所欲，代码即变的境界。 然后，可以创建容器来运行应用程序。大多数Docker容器启动时间不到1秒。由于管理程序的费用，Docker容器性能高，同时，更多的容器也可以在同一宿主机中运行，让用户尽可能充分利用系统资源。

(2)职责的逻辑分类

使用Docker，开发人员只需要关心容器中的应用程序，而运维人员只需要关心如何管理容器。Docker设计的目的是加强开发人员编写代码的开发环境与应用程序部署的生产环境的一致性。从而减少开发过程中一切正常，必须是运维问题（测试环境正常，在线问题归因于运维问题）

(3)生命周期的快速高效发展

Docker的目标之一就是缩短代码从开发、测试到部署、上线运行的周期，让你的应用程序具备可移植性，易于构建，并易于协作。（通俗一点说，Docker就像一个盒子，里面可以装很多。如果你需要这些东西，你可以直接把大盒子拿走，而不是从盒子里拿走。

(4)鼓励使用面向服务的架构

Docker还鼓励面向服务的系统结构和微服务架构。Docker建议单个容器只运行一个应用程序或过程，从而形成一个分布式应用程序模型，在该模型下，应用程序或服务可以表示为一系列内部互联容器，使分布式部署应用程序、扩展或调试应用程序变得非常简单，但也提高了程序的节省。(当然，多个应用程序可以在一个容器中运行)

Docker是客户端-服务器（C/S）架构程序。Docker客户端只需要方向Docker要求服务器或保护过程完成所有工作并返回结果。Docker提供命令行工具Docker以及一整套RESTful API。您可以在同一台宿主机上运行Docker守护过程和客户端也可以来自当地Docker客户端连接到运行在另一台宿主机上的远程客户端Docker守护进程。

下面是Docker基础架构：

镜像是构建Docker基石。用户基于镜像操作自己的容器。镜像也是Docker生命周期中的构建部分。镜像是基于联合文件系统的层次结构，由一系列指令逐步构建。

添加文件；

执行命令；

打开窗户。

镜像也可以作为容器的源代码。镜像体积小，非常便携，易于分享、存储和更新。

Docker它可以帮助您构建和部署容器，您只需将您的应用程序或服务包装到容器中。容器是基于镜像启动的，一个或多个过程可以在容器中运行。我们可以认为镜像是Docker构建或打包生命周期，而容器是启动或执行阶段。 基于镜像启动的容器，一旦完成，我们就可以登录到容器中安装所需的软件或服务。

所以Docker容器就是：

镜像格式；

一些列标准操作；

执行环境。

Docker借鉴标准集装箱的概念。标准集装箱将货物运输到世界各地，Docker将这个模型应用到自己的设计中，唯一不同的是:而集装箱运输货物Docker运输软件。

和集装箱一样，Docker在执行上述操作时，并不关心容器中到底装了什么，它不管是web服务器、数据库或应用程序服务器。所有容器都以同样的方式装载内容。

Docker也不在乎你要把容器运到哪里：我们可以在自己的笔记本上构建容器，上传到Registry，然后下载到物理或虚拟服务器进行测试，并将容器部署到特定的主机中。像标准容器一样，Docker容器易更换，可叠加，易分发，尽量通用。

Docker用Registry保存用户构建的镜像。Registry分为公共和私有两种。Docker公司公开经营Registry叫做Docker Hub。用户可以在Docker Hub注册账号，分享并保存自己的镜像(注:在Docker Hub下载镜像很慢，可以自己构建私人镜像Registry）。 https://hub.docker.com/

镜像(image)

Docker镜像是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外。  

容器（Container）

镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等 。

注册中心（Registry）

Docker官方建议在Ubuntu中安装，因为Docker是基于Ubuntu发布的，而且一般Docker出现的问题Ubuntu是最先更新或者打补丁的。在很多版本的CentOS中是不支持更新最新的一些补丁包的。

由于我们学习的环境都使用的是CentOS，因此这里我们将Docker安装到CentOS上。注意：这里建议安装在CentOS7.x以上的版本，在CentOS6.x的版本中，安装前需要安装其他很多的环境而且Docker很多补丁不支持更新。

请直接挂载课程配套的Centos7.x镜像

• 删除安装过的docker

# 查看linux内核版本
uname -r
# 查看是否已经安装过
yum list installed | grep docker
# 删除之前安装的docker
yum remove -y docker-ce docker-ce-cli containerd.io
# 删除之前生成的docker数据
rm -rf /var/lib/docker

• 安装docker

# 安装依赖工具
yum install -y yum-utils device-mapper-persistent-data lvm2
# 设置阿里云镜像
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 必须先更新yum源，否则找不到docker-ce，只能找到docker
yum makecache fast
# 查看仓库的可安装版本
yum list docker-ce --showduplicates|sort -r  
# 安装64位的版本
yum install -y docker-ce.x86_64

• 检查是否安装成功

# 检查是否安装成功
yum list installed | grep docker
# 或  查看版本信息
docker -v 
docker version 
# 查询docker 详细信息
docker info
# 查看命令
docker --help
# 查看指定命令相关选项信息
docker 命令 --help

# 查看docker服务状态
systemctl status docker
# 启动docker服务端
systemctl start docker
# 停止docker服务端
systemctl stop docker
# 重启docker服务端
systemctl restart docker
# 设置docker 服务端开机启动
systemctl enable docker

配置阿里云的镜像加速器地址:

https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

点击镜像加速服务:

# 命令1: 如果/etc/docker/daemon.json 不存在

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://628fm69f.mirror.aliyuncs.com"]
}
EOF

# 命令2: 如果/etc/docker/daemon.json 存在
vi /etc/docker/daemon.json
# 贴入自己的加速镜像地址


# 重新加载配置 重启docker服务端
sudo systemctl daemon-reload
sudo systemctl restart docker


总结：
cd /etc/docker/
vi daemon.json
{
  "registry-mirrors": ["https://ymn6yyq6.mirror.aliyuncs.com"]
}

## 04_Docker的基本操作

1）查看镜像
	# 查看所有镜像
	docker images
	
	#REPOSITORY  镜像仓库名称 
	#TAG         镜像的版本    
	#IMAGE ID    镜像的ID
	#CREATED     镜像创建的时间
	#SIZE        镜像的大小docker images
	#这些镜像都是存储在Docker宿主机的/var/lib/docker目录下

如果你需要从网络中查找需要的镜像，可以通过以下命令搜索

	#1. 可以通过网页去注册中心搜索
	https://hub.docker.com/
	
    #2. docker命令搜索
    docker search 镜像仓库名称

拉取镜像就是从中央仓库中下载镜像到本地

	docker pull 注册中心地址/镜像仓库名称:镜像版本
	代表去指定的注册中心 下载指定的版本
	docker pull 镜像仓库名称:镜像版本
	代表去默认的注册中心下载指定的版本
	docker pull 镜像仓库名称
	代表去默认的注册中心  下载 latest版本

例如，我要下载centos7镜像

docker pull centos:7

按镜像ID删除镜像

docker rmi 镜像仓库名称:版本
docker rmi 镜像ID

删除所有镜像, 谨慎使用

docker rmi `docker images -q`  

查看正在运行的容器

docker ps

查看所有容器

docker ps –a

查看所有容器列表 只显示容器ID

docker ps -a  -q

查看最后一次运行的容器

docker ps –l

查看停止的容器

docker ps -f status=exited

创建容器常用的参数说明：

创建容器命令：docker run [选项] 镜像仓库名称:版本号（镜像ID） [命令]

-i：表示运行容器

-t：表示容器启动后会进入其命令行。加入这两个参数后，容器创建就能登录进去。即分配一个伪终端。

–name :为创建的容器命名， 必须是唯一的。

-v：表示目录映射关系（前者是宿主机目录，后者是映射到宿主机上的目录），可以使用多个－v做多个目录或文件映射。注意：最好做目录映射，在宿主机上做修改，然后共享到容器上。

-d：在run后面加上-d参数,则会创建一个守护式容器在后台运行（这样创建容器后不会自动登录容器，如果只加-i -t两个参数，创建后就会自动进去容器）。

-p：表示端口映射，前者是宿主机端口，后者是容器内的映射端口。可以使用多个-p做多个端口映射

（1）交互式运行容器 创建并运行容器后，会登录到容器中

# 创建并运行容器       进入到这个容器中  运行 bash脚本
docker run -it  --name mycentos  centos:7  /bin/bash

# 如果要从容器内部退出
exit 

# 从容器退出后，容器会立刻关闭

（2）守护式方式创建容器：

# 创建并运行容器       进入到这个容器中  运行 bash脚本
docker run -id  --name mycentos2  centos:7

# 进入正在运行的容器中
到我的mycentos2容器中  执行bash命令
docker exec -it mycentos2 bash

# 如果要从容器内部退出
exit

# 从容器退出后，容器不会关闭

登录守护式容器方式：

docker exec -it 容器名称 (或者容器ID)  /bin/bash

停止容器：

docker stop 容器名称（或者容器ID）
#如:
docker stop mycentos2
停止名称为mycentos2的容器

启动容器：

docker start 容器名称（或者容器ID）
#如:
docker start mycentos2 
启动名称为mycentos2的容器

重启容器：

docker restart 容器名称（或者容器ID）
#如:
docker restart mycentos2 
重启名称为mycentos2的容器

如果我们需要将文件拷贝到容器内可以使用cp命令

docker cp 要拷贝的宿主机文件地址  容器名称:容器内的目录地址
docker cp /root/hehe.html mycentos2:/

也可以将文件从容器内拷贝出来

docker cp 容器名称:容器内的要拷贝的文件地址   宿主机目录
docker cp mycentos2:/hehe.html  /root

如:

# 在linux中的/root文件夹创建hello.html文件
touch /root/hello.html

# 将/root/hello.html文件拷贝的容器中的根目录中
docker cp /root/hello.html mycentos2:/

# 将容器中根目录下的hello.html 拷贝到 虚拟机中的根目录
docker cp mycentos2:/hello.html /

可以将宿主机的目录 和 容器内的目录挂载到一起 挂载后可以理解为两个目录有了一个"双向绑定"的关系 只要在宿主机的挂载目录创建或修改了文件， 在容器内的指定目录也会看到对应的变化

挂载在创建容器的时候指定 通过 -v 宿主机的目录:容器内的目录

docker run -di --name mycentos3   -v /data/docker:/usr/myDocker   centos:7

如果你共享的是多级的目录，可能会出现权限不足的提示。

这是因为CentOS7中的安全模块selinux把权限禁掉了，我们需要添加参数 –privileged=true 来解决挂载的目录没有权限的问题

我们可以通过以下命令查看容器运行的各种数据

docker inspect 容器名称（容器ID） 

也可以直接执行下面的命令直接输出IP地址

docker inspect --format='{
    
       {.NetworkSettings.IPAddress}}' 容器名称（容器ID）

删除指定的容器：

# 删除容器
docker rm  容器名称或容器ID
# 强制删除
docker rm  -f 容器名称或容器ID
# 删除全部容器 (慎用)
docker rm `docker ps -a -q`

查看容器运行日志

# 设置只要docker一重启，容器就会自动启动
docker update --restart=always mycentos3

# 查看容器日志
docker logs -f 容器名称或容器ID

数据卷 是一个可供一个或多个容器使用的特殊目录，一般是在宿主机的某个特定的目录下。可以提供很多有用的特性：

• 数据卷 可以在容器之间共享和重用
• 对 数据卷 的修改会立马在挂载数据卷的容器中可见
• 对 数据卷 的更新，不会影响镜像
• 数据卷 默认会一直存在，即使容器被删除

通过docker volume命令可以管理数据卷，语法包括：

[root@localhost ~]# docker volume --help
Usage:  docker volume COMMAND
Manage volumes
Options:
      --help   Print usage

Commands:
  create      Create a volume
  inspect     Display detailed information on one or more volumes
  ls          List volumes
  prune       Remove all unused volumes
  rm          Remove one or more volumes

说明：docker volume COMMAND

• COMMAND：要运行的数据卷指令
  • create：创建一个数据卷
  • inspect：显示一个或多个指定数据卷的详细信息
  • ls：查看所有的数据卷
  • prune：删除所有未使用的数据卷
  • rm：删除一个或多个指定的数据卷

通过docker volume create来实现，示例：

# 创建一个名为html的数据卷
docker volume create html

通过docker volume ls查看所有的数据卷：

只有在创建容器时才可以挂载数据卷。

创建一个容器，并挂载刚刚指定的数据卷：

# 创建并运行一个nginx容器    
docker run -id  --name=my-nginx -p 8888:80 -v html:/usr/share/nginx/html nginx

然后，通过命令查看数据卷html在宿主机的物理地址：

docker volume inspect html

结果：

[
    { 
        
        "Driver": "local",
        "Labels": { 
        },
        "Mountpoint": "/var/lib/docker/volumes/html/_data",
        "Name": "html",
        "Options": { 
        },
        "Scope": "local"
    }
]

进入该目录查看：

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

修改这个index.html文件：

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<title>传智播客官网-好口碑IT培训机构,一样的教育,不一样的品质</title>
<style> body { 
           width: 35em; margin: 0 auto; font-family: Tahoma, Verdana, Arial, sans-serif; } </style>
</head>
<body>
<h1>欢迎来黑马程序员学习!</h1>
<p>传智播客专注IT培训,提供多种IT培训服务，如：Java培训,人工智能培训,Python培训,PHP培训,C++培训,大数据培训,UI设计培训,移动开发培训,网络营销培训,web前端培训,全栈工程师培训,产品经理培训等，是业内口碑较好的IT培训机构。.</p>

<p>查看最新开班信息：
<a href="http://www.itcast.cn">传智播客</a>.<br/></p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

再次访问你的虚拟机地址:http://youIp

注意：如果在运行容器时指定了数据卷，而数据卷不存在，docker会自动创建一个数据卷。

除了挂载数据卷以外，docker也允许你挂载一个指定的本地目录或者本地文件。比如我希望在运行nginx的同时挂载一个本地的nginx配置文件，方便以后修改nginx配置。

首先，我们在宿主机的任意目录，创建一个文件：nginx.conf，

# 编辑nginx.conf文件
vi nginx.conf

内容如下：

  worker_processes  1;
  events {
      worker_connections 1024;
  }  
  http {
      default_type  text/html; # 默认响应类型是html

    server {
      listen 80;
      location /s {
              # 以/s开头的路径，会代理到百度
        proxy_pass https://www.baidu.com;
      }
      location / {
        root	/usr/share/nginx/html;
      }
    }
  }

然后，我们删除之前的nginx容器：

docker rm my-nginx -f

创建一个新的容器：

docker run --name my-nginx -p 8888:80 -v html:/usr/share/nginx/html -v $PWD/nginx.conf:/etc/nginx/nginx.conf --privileged=true -id nginx

命令说明：

• --name my-nginx：容器名称为my-nginx
• -p 80:80：将容器的80端口映射到宿主机的80端口
• -v html:/usr/share/nginx/html：挂载html数据卷到容器的/usr/share/nginx/html目录
• -v $PWD/nginx.conf:/etc/nginx/nginx.conf：
  • $PWD/nginx.conf：当前目录下的nginx.conf文件
  • 把宿主机当前目录下的nginx.conf文件挂载到容器内的/etc/nginx/nginx.conf文件
• --privileged：授予本地目录的访问权限
• -d：后台运行
• nginx：镜像名称

然后，在浏览器访问：http://youIp/s，例如我的：http://161.189.111.227:8888/s：

数据卷  代表一个特殊的目录
做目录挂载的时候，可以直接通过数据卷来挂载
docker volume --help 

# 创建数据卷
docker volume create 

# 查看详细信息
docker volume inspect

# 删除不适用数据卷
docker volume prune 

当我们要部署基于docker的微服务群时，往往会需要容器之间互相连接。这时就需要用到Docker中的网络配置了。

通过docker network命令可以管理docker网络。

[root@localhost ~]# docker network --help

Usage:  docker network COMMAND
Manage networks
Options:
      --help   Print usage
Commands:
  connect     Connect a container to a network
  create      Create a network
  disconnect  Disconnect a container from a network
  inspect     Display detailed information on one or more networks
  ls          List networks
  prune       Remove all unused networks
  rm          Remove one or more networks

说明：

• connect：把一个容器连接到指定的network
• create：创建一个network
• disconnect：将一个容器从指定的network断开
• inspect：显示某个network的详细信息
• ls：列出所有的network
• prune：删除未使用的network
• rm：删除指定的一个或多个network

通过docker network create命令来创建，示例：

docker network create -d bridge my-net

说明：

• -d：指定网络类型，可以是：bridge、overlay，默认是bridge

关于网络模式参考：

https://docs.docker.com/network/

https://www.jianshu.com/p/22a7032bb7bd

通过docker network ls查看network，示例：

可以看到，除了我们刚刚创建的my-net外，还有几个默认的网络。

另外，还可以通过命令查看具体信息：

docker network inspect my-net

结果：

[
    { 
        
        "Name": "my-net",
        "Id": "bf3efa08d055d38c44cabee47bbd45145dd69d7d6609028e9b9905cf0f17f7a7",
        "Created": "2020-07-07T16:11:48.193977107+08:00",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": { 
        
            "Driver": "default",
            "Options": { 
        },
            "Config": [
                { 
        
                    "Subnet": "172.19.0.0/16",
                    "Gateway": "172.19.0.1"
                }
            ]
        },
        "Internal": false,
        "Attachable": false,
        "Containers": { 
        },
        "Options": { 
        },
        "Labels": { 
        }
    }
]

可以将一个已经运行的容器连接到某个network：

docker network connect my-net my-nginx

也可以在创建容器时，连接一个network：

docker run -it --rm --name mycentos --network=my-net centos:7 /bin/bash

说明：

• -it：运行容器并保持一个可交互的shell终端
• --rm：容器退出时，自动删除容器
• --network my-net：连接到my-net网络

运行后会自动进入容器，并开启一个shell终端，为了测试网络，我们可以执行命令：

ping my-nginx

用容器名去测试连接：

每一个创建的容器 都会有容器内部IP地址，docker会默认准备一个 172.17.0.1的网络地址

我们也可以自己创建网络:
# 创建一个网络
docker network create

容器与容器之间可以通过内部IP相互访问

好处:
1. 不通过宿主机转发，直接内部访问 速度更快

2. 不对外暴露自己的地址更安全

3. 在自定的网络中 还可以直接通过容器名称相互访问，更方便

我们可以通过以下命令将容器保存为镜像 (基于修改过的容器保存成一个新的镜像)

我们可以通过以下命令将镜像保存为tar 文件 (将镜像备份成压缩包)

docker  save -o mynginx.tar mynginx_i

首先我们先删除掉mynginx_img镜像 然后执行此命令进行恢复 (加载备份的镜像压缩包)

docker load -i mynginx.tar

#-i 输入的文件
#执行后再次查看镜像，可以看到镜像已经恢复

（1）拉取mysql镜像

docker pull mysql:5.7

（2）创建并运行容器

docker run -id -p 3306:3306 --name=mysql -v /root/mysql/conf:/etc/mysql/conf.d -v /root/mysql/logs:/logs -v /root/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root mysql:5.7

-p 代表端口映射，格式为 宿主机映射端口:容器运行端口

-e 代表添加环境变量 MYSQL_ROOT_PASSWORD 是root用户的登陆密码

（3）远程登录mysql

连接宿主机的IP ,指定端口为3306

如果出现异常：IPv4 forwarding is disabled. Networking will not work

解决方案：

vi /etc/sysctl.conf
net.ipv4.ip_forward=1  #最下方添加这段代码
#重启network服务
systemctl restart network && systemctl restart docker
#查看是否修改成功 （备注：返回1，就是成功）
[root@docker-node2 ~]# sysctl net.ipv4.ip_forward
net.ipv4.ip_forward = 1

（1）拉取镜像

docker pull tomcat

（2）创建并运行容器

创建容器 -p表示地址映射

docker run -id --name mytomcat -p 9000:8080 -v mytomcat:/usr/local/tomcat/webapps  tomcat

（1）拉取RabbitMQ镜像

docker pull rabbitmq:3-management

如果网络较慢使用资料中提供好的镜像资料mq.tar并导入

导入命令：docker load -i mq.tar

（2）运行MQ容器

docker run \
 -e RABBITMQ_DEFAULT_USER=guest \
 -e RABBITMQ_DEFAULT_PASS=guest \
 --name mq \
 --hostname mq1 \
 -p 15672:15672 \
 -p 5672:5672 \
 -id \
 rabbitmq:3-management

（3）浏览器测试访问http://192.168.200.150:15672/

（1）拉取镜像

docker pull redis

（2）创建并运行容器

docker run -di --name=myredis -p 6379:6379 redis

（1）拉取镜像

docker pull nginx:latest

（2）创建并运行容器

docker run -id --name my-nginx -p 8888:80  -v html:/usr/share/nginx/html  -v $PWD/nginx.conf:/etc/nginx/nginx.conf   nginx:latest

（2) 管理容器

docker stop my-nginx
# docker重启 容器会自动启动
docker update --restart=always my-nginx

Dockerfile是由一系列命令和参数构成的脚本，这些命令应用于基础镜像并最终创建一个新的镜像。

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

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

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

attach    Attach to a running container           # 当前 shell 下 attach 连接指定运行镜像
build     Build an image from a Dockerfile            # 通过 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                    # 创建一个新的容器，同 run，但不启动容器
diff      Inspect changes on a container's filesystem   # 查看 docker 容器变化
events    Get real time events from the server          # 从 docker 服务获取容器实时事件
exec      Run a command in an existing container        # 在已存在的容器上运行命令
export    Stream the contents of a container as a tar archive   # 导出容器的内容流作为一个 tar 归档文件[对应 import ]
history   Show the history of an image                  # 展示一个镜像形成历史
images    List images                                   # 列出系统当前镜像
import    Create a new filesystem image from the contents of a tarball # 从tar包中的内容创建一个新的文件系统映像[对应export]
info      Display system-wide information               # 显示系统相关信息
inspect   Return low-level information on a container   # 查看容器详细信息
kill      Kill a running container                      # kill 指定 docker 容器
load      Load an image from a tar archive         # 从一个 tar 包中加载一个镜像[对应 save]
login     Register or Login to the docker registry serve # 注册或者登陆一个 docker 源服务器
logout    Log out from a Docker registry server          # 从当前 Docker registry 退出
logs      Fetch the logs of a container                 # 输出当前容器日志信息
port      Lookup the public-facing port which is NAT-ed to PRIVATE_PORT    # 查看映射端口对应的容器内部源端口
pause     Pause all processes within a container        # 暂停容器
ps        List containers                               # 列出容器列表
pull      Pull an image or a repository from the docker registry server   # 从docker镜像源服务器拉取指定镜像或者库镜像
push      Push an image or a repository to the docker registry server    # 推送指定镜像或者库镜像至docker源服务器
restart   Restart a running container                   # 重启运行的容器
rm        Remove one or more containers                 # 移除一个或者多个容器
rmi       Remove one or more images             # 移除一个或多个镜像[无容器使用该镜像才可删除，否则需删除相关容器才可继续或 -f 强制删除]
run       Run a command in a new container              # 创建一个新的容器并运行一个命令
save      Save an image to a tar archive            # 保存一个镜像为一个 tar 包[对应 load]
search    Search for an image on the Docker Hub         # 在 docker hub 中搜索镜像
start     Start a stopped containers                    # 启动容器
stop      Stop a running containers                     # 停止容器
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           # 查看 docker 版本号
wait      Block until a container stops, then print its exit # 截取容器停止时的退出状态值

使用Dockerfile脚本，构建一个安装了JDK的centos镜像 步骤：

（1）创建目录

mkdir –p /usr/local/dockerjdk8

（2）下载jdk-8u171-linux-x64.tar.gz并上传到服务器（虚拟机）中的/usr/local/dockerjdk8目录

（3） 在dockerjdk8目录创建脚本文件 : Dockerfile

（4）编辑构建镜像的脚本 vi Dockerfile

# 基于centos7构建
FROM centos:7
# 声明作者名称
MAINTAINER dadahai
# 创建一个用于存放jdk的文件夹
#切换工作目录
WORKDIR /usr
RUN mkdir /usr/local/java
# 将JDK的压缩包拷贝并解压到指定目录
ADD jdk-8u171-linux-x64.tar.gz /usr/local/java
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_171
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

（4）执行命令构建镜像

docker build -t='jdk8' .
docker build -t='jdk8:1.8' .  # 指定tag版本

注意后边的空格和点，不要省略

（5）查看镜像是否建立完成

docker images

（1）拉取私有仓库镜像（此步省略）

docker pull registry

（2）启动私有仓库容器

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

（3）打开浏览器 输入地址http://192.168.200.150:5000/v2/_catalog看到{"repositories":[]} 表示私有仓库搭建成功并且内容为空

（4）修改daemon.json

cd /etc/docker/ 然后 vi daemon.json
或者直接
vi /etc/docker/daemon.json

添加以下内容，保存退出。

{ 
        
    ,"insecure-registries":["192.168.200.130:5000"]
}

此步用于让 docker信任私有仓库地址

（5）重启docker 服务

systemctl daemon-reload && systemctl restart docker

（1）标记此镜像为私有仓库的镜像

docker tag jdk8 192.168.200.130:5000/jdk8

（2）再次启动私服容器

docker start registry

（3）上传标记的镜像

docker push 192.168.200.130:5000/jdk8

首先大家要知道，一般小公司没有专门的Docker工程师去维护镜像，或者说我们打包好的镜像也不能说用硬盘来拷贝吧，这时我们需要将自己的镜像推送的远程仓库管理。

**阿里云镜像服务地址https://cr.console.aliyun.com/cn-hangzhou/instances

1. 创建阿里云仓库镜像的命名空间和仓库名称

2. 将镜像推送到registry

   # 登录到阿里云镜像
   docker login --username=yinbi786247 registry.cn-hangzhou.aliyuncs.com
   
   # 将要推送的镜像 通过tag重新标记
   docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/hf-docker/docker_rep:[镜像版本号]
   
   # 推送指定镜像到阿里云
   docker push registry.cn-hangzhou.aliyuncs.com/hf-docker/docker_rep:[镜像版本号]
   
   

   请根据实际镜像信息替换示例中的[ImageId]和[镜像版本号]参数。

3. 阿里云查询是否推送成功

 docker pull registry.cn-hangzhou.aliyuncs.com/hf-docker/docker_rep:[镜像版本号]

​ Portainer是Docker的图形化管理工具，提供状态显示面板、应用模板快速部署、容器镜像的基本操作（包括上传下载镜像，创建容器等操作）、事件日志显示、容器控制台操作、登录用户管理和控制等功能。功能十分全面，基本能满足中小型单位对容器管理的全部需求。

官方安装教程： https://www.portainer.io/installation/

#准备汉化插件
mkdir -p /data/portainer/public

将资料中 Portainer-CN.zip拷贝到此文件夹，并解压
# 拷贝到对应文件夹
mv ./Portainer-CN.zip /data/portainer/public/

# 进入该文件夹解压
cd /data/portainer/public/

# 解压
unzip Portainer-CN.zip

#创建并启动容器
docker run -id --name portainer \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data \
    -v /data/portainer/public:/public \
    --privileged \
    --hostname portainer \
    -p 9001:9000 portainer/portainer

--restart=always 开机自动启动

访问：ip:9000 第一次登陆需要设置登陆密码，密码不得少于8位

选择管理本地docker还是远程。此处选择暂选Local

查看本地Docker服务器的列表信息

选择一个Docker服务，即可查看其内部的详情信息，如镜像、容器等

选择Containers选项卡，即可查看当前容器的相关详细信息，并可以完成对容器的相关操作

此处以安装Nignx为例

1）点击app templates选项卡

2）点击列表中的nginx，进入如下页面

3）设置name，之后点击Show advanced options，完成端口映射配置

4）点击deploy the container完成创建