Docker

虚拟化介绍

概述

• 在计算机中，虚拟化（英语：Virtualization）是一种资源管理技术，是将计算机的各种实体资源，如服务器、网络、内存及存储等，予以抽象、转换后呈现出来，打破实体结构间的不可切割的障碍，使用户以更好的方式来应用这些资源。这些资源的新虚拟部分是不受现有资源的架设方式，地域或物理组态所限制。一般所指的虚拟化资源包括计算能力和资料存储。
• 在实际的生产环境中，虚拟化技术主要用来解决高性能的物理硬件产能过剩和老的旧的硬件产能过低的重组重用，透明化底层物理硬件，从而实现对资源的最大化利用
• 虚拟化技术种类很多， 例如：软件虚拟化、硬件虚拟化、内存虚拟化、网络虚拟化、桌面虚拟化等等。

虚拟化架构种类

• 全虚拟化架构
  虚拟机的监视器（hypervisor）是类似于用户的应用程序运行在主机的OS之上，如VMware的workstation，这种虚拟化产品提供了虚拟的硬件)。
  

说明: 虚拟出来的操作系统可以与本机操作系统不一样(内核)。

• OS层虚拟化架构
  

说明: 虚拟出来的操作系统与本机操作系统一样(内核)。

• 硬件层虚拟化架构
  

说明: 虚拟出来的操作系统是没有宿主机操作系统。

Docker介绍

简介

• Docker 是一个开源的应用容器引擎，基于 Go 语言开发。Docker 可以让开发者打包他们的应用以及相关依赖到一个轻量级、可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间完全隔离， 更重要的是容器性能开销极低。

好处

• 使用Docker可以实现开发人员的开发环境、测试人员的测试环境、运维人员的生产环境的一致性。
• 提高了运维效率
  
  Docker借鉴了标准集装箱的概念。标准集装箱将货物运往世界各地，Docker将这个模型运用到自己的设计中，唯一不同的是：集装箱运输货物，而Docker运输软件。

容器&虚拟机对比

	虚拟机	容器
占用磁盘空间	非常大，GB级	小，MB甚至KB级
启动速度	慢，分钟级	快，秒级
运行形态	运行于Hypervisor上	直接运行在宿主机内核上
并发性	一台宿主机上十几个，最多几十个	上百个，甚至数百上千个
性能	逊于宿主机	接近宿主机本地进程
资源利用率	低	高

小结

• Docker容器是在操作系统层面上实现虚拟化，直接复用本地主机的操作系统，而传统虚拟机则是在硬件层面实现虚拟化。与传统的虚拟机相比，Docker优势体现为启动速度快、占用体积小。

Docker：组成结构

名称	说明
Docker 镜像 (Images)	Docker 镜像是用于创建 Docker 容器的模板。镜像是基于联合文件系统的一种层式结构， 由一系列指令一步一步构建出来(只读不能修改)。
Docker 容器 (Container)	容器是独立运行的一个或一组应用。镜像相当于类，容器相当于类的对象，相当于操作系统
Docker 客户端(Client)	Docker 客户端通过命令行或者其他工具使用 Docker API 与 Docker 的守护进程通信。
Docker 主机(Host)	一个物理或者虚拟的机器用于执行 Docker 守护进程和容器。
Docker守护进程	是Docker服务器端进程，负责支撑Docker 容器的运行以及镜像的管理。
Docker 仓库 DockerHub(Registry)	Docker 仓库用来保存镜像，可以理解为代码控制中的代码仓库。 Docker Hub提供了庞大的镜像集合供使用。用户也可以将自己本地的镜像推送到Docker仓库供其他人下载。

官方仓库: https://hub.docker.com/

Docker：安装

• Docker 可以运行在 MAC、Windows、CentOS、UBUNTU等操作系统上，提供社区版和企业版，本课程基于 CentOS7 安装Docker。

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

安装步骤

# 1. yum 更新已有rpm包，升级linux内核(不做也可以)
yum update

# 2. 安装需要的软件包，yum-util提供yum-config-manager功能，另外两个是devicemapper驱动依赖
yum install -y yum-utils device-mapper-persistent-data lvm2

# 3. 设置yum源为阿里云
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 4. 安装docker【docker-ce: 社区版，免费；docker-ee：企业版，收费】
yum install docker-ce -y

# 5. 安装后查看docker版本
docker -v

Docker：设置ustc镜像源

操作步骤

• 创建并编辑文件/etc/docker/daemon.json

  # 执行如下命令
  mkdir /etc/docker
  vi /etc/docker/daemon.json  
  

• 在文件中加入下面内容:

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

Docker：服务相关命令

常用命令

# 启动docker服务
systemctl start docker
# 停止docker服务
systemctl stop docker
# 重启docker服务
systemctl restart docker
# 查看docker服务状态
systemctl status docker
# 设置开机启动docker服务
systemctl enable docker
# 设置开机不自动启动
systemctl disable docker
# 查看docker概要信息
docker info
# 查看docker帮助文档
docker --help

Docker：镜像相关命令

镜像介绍

• Docker镜像是由文件系统叠加而成（是一种文件的存储形式），是docker中的核心概念，可以认为镜像就是对某些运行环境以及软件打的包。

• 用户可以从docker仓库中下载基础镜像到本地，比如开发人员可以从docker仓库下载一个只包含centos7系统的基础镜像，把基础镜像运行成为一个容器（容器相当于操作系统），然后在这个容器中安装jdk、mysql、Tomcat、部署war包，最后将容器打成一个新的镜像。开发人员将这个新的镜像提交给测试人员进行测试，测试人员只需要在测试环境下运行这个镜像成一个容器就可以了，这样就可以保证开发环境和测试环境完全一致。
  
  查看镜像

  # 查看镜像可以使用如下命令:
  docker images
  

• REPOSITORY: 镜像名称
• TAG: 镜像标签 (默认是可以省略的,也就是latest)
• IMAGE ID: 镜像ID
• CREATED: 镜像的创建日期（不是获取该镜像的日期）
• SIZE: 镜像大小

搜索镜像

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

• NAME: 镜像名称
• DESCRIPTION: 镜像描述
• STARS: 用户评价，反应一个镜像的受欢迎程度
• OFFICIAL: 是否官方
• AUTOMATED: 自动构建，表示该镜像由Docker Hub自动构建流程创建的

拉取镜像

# 拉取镜像就是从Docker仓库下载镜像到本地，镜像名称格式为 名称:版本号，如果版本号不指定则是最新的版本 命令如下:
docker pull 镜像名称

# 拉取centos 7
docker pull centos:7
# 拉取centos 最后版本镜像
docker pull centos:latest

删除镜像

# 按照镜像id删除镜像，或者镜像名称:版本号
docker rmi 镜像ID
# 删除所有镜像(谨慎操作)
docker rmi `docker images -q`

Docker：容器相关命令

查看容器

• 查看正在运行容器: docker ps

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

• 查看最后一次运行的容器: docker ps –l

创建与运行容器

• 可以基于已有的镜像来创建容器，创建与运行容器使用命令: docker run
• 参数说明：

-i: 表示运行容器

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

--name: 为创建的容器命名(名称不能重复)。

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

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

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

交互式容器

• 以交互式方式创建并运行容器，启动完成后，会直接进入当前容器。使用exit命令退出容器。以此种方式创建并启动容器，如果（第一次）退出容器，则容器会变成停止状态。

# 先拉取一个镜像；这一步不是每次启动容器都要做的，而是因为前面我们删除了镜像，
# 无镜像可用所以才再拉取一个
docker pull centos:7

# 创建并启动名称为 mycentos7 的交互式容器
# 容器名称 mycentos7
# 镜像名称:TAG (centos:7)  也可以使用镜像id (5e35e350aded)
# /bin/bash: 进入容器命令行
docker run -it --name=mycentos7 centos:7 /bin/bash

守互式容器

• 对于一个需要长期运行的容器来说，我们可以创建一个守护式容器，命令如下（容器名称不能重复）

# 创建并启动守护式容器
# 容器名称: mycentos2
# 镜像名称:TAG (centos:7)  也可以使用镜像id (5e35e350aded)
docker run -di --name=mycentos2 centos:7

# 进入容器：
# docker exec -it container_name (或者 container_id) /bin/bash
# exit退出时，容器不会停止
docker exec -it mycentos2 /bin/bash

说明: 守护式容器是一直运行的，退出只是退出终端，它还是在后台运行。

停止或启动容器

# 停止正在运行的容器: docker stop 容器名称|容器ID
docker stop mycentos2

# 启动已运行过的容器: docker start 容器名称|容器ID
docker start mycentos2

重启容器

# 重启正在运行的容器: docker restart 容器名称|容器ID
docker restart mycentos2

查看容器信息（包括ip）

# 在linux宿主机下查看 mycentos2 的ip
# docker inspect 容器名称（容器ID）

docker inspect mycentos2

容器之间在一个局域网内，linux宿主机器可以与容器进行通信；但是外部的服务器是不能与容器直接通信的，如果需要则需要通过宿主机器端口的代理。

删除容器

• 删除指定的容器: docker rm 容器名称|容器ID
• 删除所有容器: docker rm `docker ps -a -q`

docker rm mycentos2
# 或者
docker rm 2095a22bee70

# 删除所有容器
docker rm `docker ps -a -q`

说明: 如果容器是运行状态则删除失败，需要停止容器才能删除

Docker：容器文件拷贝

将linux宿主机中的文件拷贝到容器内可以使用命令:

# docker cp 需要拷贝的文件或目录 容器名称:容器目录

# 创建一个文件abc.txt 
touch abc.txt

# 复制 abc.txt 到 mycentos2 的容器的 / 目录下 
docker cp abc.txt mycentos2:/ 

# 进入mycentos2容器 
docker exec -it mycentos2 /bin/bash 

# 查看容器 / 目录下文件
ll

将文件从容器内拷贝出来到linux宿主机使用命令:

# docker cp 容器名称:容器目录 需要拷贝的文件或目录

# 进入容器后创建文件aaa.txt
touch aaa.txt

# 退出容器
exit

# 在Linux宿主机器执行复制；将容器mycentos2的/aaa.txt文件复制到 宿主机器的/root目录下
docker cp mycentos2:/aaa.txt /root

注意: 停止状态的容器也是可以进行文件拷贝的，可以拷进去，也可以拷出来。

Docker：容器目录挂载

• 可以在创建容器的时候，将宿主机的目录与容器内的目录进行映射，这样我们就可以通过修改宿主机某个目录的文件从而去影响容器。

• 创建容器时添加-v参数，后边为宿主机目录:容器目录，例如： docker run -di -v /usr/local/test:/usr/local/test --name=mycentos3 centos:7（两个目录可以路径不同）

  # 创建linux宿主机器要挂载的目录 
  mkdir /usr/local/test 
  
  # 创建并启动容器mycentos3
  # 并挂载 linux中的/usr/local/test目录到容器的/usr/local/test
  # 也就是在 linux中的/usr/local/test中操作相当于对容器相应目录操作 
  docker run -di -v /usr/local/test:/usr/local/test --name=mycentos3 centos:7
  
  # 在linux宿主机下创建文件 
  touch /usr/local/test/bbb.txt
  
  # 进入容器 
  docker exec -it mycentos3 /bin/bash
  
  # 在容器中查看目录中是否有对应文件bbb.txt
  cd /usr/local/test
  ll
  

注意: 如果你共享的是多级的目录，可能会出现权限不足的提示。 这是因为CentOS7中的安全模块selinux把权限禁掉了，需要添加参数 --privileged=true 来解决挂载的目录没有权限的问题。

Docker：安装mysql容器

操作步骤

• 第一步：拉取镜像

# 拉取MySQL 5.7镜像
docker pull centos/mysql-57-centos7

• 第二步：创建容器
  docker run -di --name=mysql5.7 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root centos/mysql-57-centos7

  • -p 代表端口映射，格式为 宿主机映射端口:容器运行端口
  • -e 代表添加环境变量 MYSQL_ROOT_PASSWORD 是root用户的远程登陆密码（如果是在容器中使用root登录的话,那么其密码为空）

  # 创建mysql5.7容器 
  docker run -di --name=mysql5.7 -p 3306:3306 -e MYSQL_ROOT_PASSWORD=root centos/mysql-57-centos7
  

• 第三步：操作容器mysql

# 进入mysql5.7容器
docker exec -it mysql5.7 /bin/bash 

# 登录容器里面的mysql 
mysql -u root -p

• 第四步：远程登录mysql，使用SQLyou在windows中进行远程登录在docker容器中的mysql。
  

Docker：安装tomcat容器

操作步骤

• 第一步：拉取镜像

# 拉取tomcat镜像
docker pull tomcat

• 第二步：创建容器

# 创建tomcat容器;并挂载了webapps目录
docker run -di --name=mytomcat -p 9000:8080 -v /usr/local/tomcat/webapps:/usr/local/tomcat/webapps tomcat

# 查看日志
docker logs -f mytomcat


# 如果出现 WARNING: IPv4 forwarding is disabled. Networking will not work. 
# 执行如下操作 
# 1、编辑 sysctl.conf 
vi /etc/sysctl.conf 

# 2、在上述打开的文件中后面添加 
net.ipv4.ip_forward=1

# 3、重启network
systemctl restart network

测试访问宿主机的端口号为9000的 tomcat。地址：http://宿主机ip:9000，也可以往/user/local/tomcat/webapps下部署应用，然后再访问。

• 第三步：部署web应用

  • 创建springboot_db数据库,再创建tb_user表
  • 查看mysql5.7容器的ip地址(docker inspect mysql5.7)
    
  • 修改springboot-high工程的application.yml（数据库连接池信息），使用宿主机的ip和端口也可以，如果使用的是容器的ip和端口，前提是两个容器必须在同一个宿主机下。

  			spring:
  			  datasource:
  			  driver-class-name: com.mysql.jdbc.Driver
  			    url: jdbc:mysql://172.17.0.4:3306/springboot_db # 使用容器的ip端口或宿主机的ip端口
  			  username: root
  			    password: root
  			```
  		
  		
  			
  - 修改springboot-high工程的pom文件
  
  ```xml
  					<!--第一步，指定打war包-->
  			<packaging>war</packaging>
  			  
  			  <!--第二步，打包排除内嵌tomcat-->
  			  <dependency>
  			      <groupId>org.springframework.boot</groupId>
  			      <artifactId>spring-boot-starter-tomcat</artifactId>
  			      <scope>provided</scope>
  			  </dependency>
  			  
  			  <!--第三步，指定springboot项目打包插件-->
  			  <build>
  			     <finalName>ROOT</finalName>
  			     <plugins>
  			         <plugin>
  			             <groupId>org.springframework.boot</groupId>
  			             <artifactId>spring-boot-maven-plugin</artifactId>
  			         </plugin>
  			     </plugins>
  			  </build>
  

  • 编写WebServletInitializer类，作用等价于web.xml

  		package configuration;
  		
  		import HighApplication;
  		import org.springframework.boot.builder.SpringApplicationBuilder;
  		import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
  		
  		/**
  		 * 作用等价于web.xml
  		 *
  		 * @Author LK
  		 * @Date 2020/11/7
  		 */
  		public class WebServletInitializer extends SpringBootServletInitializer {
  		
  		    @Override
  		    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
  		        builder.sources(HighApplication.class);
  		        return builder;
  		    }
  		}
  

  • 进入项目pom文件命令行下，执行打包命令: mvn clean package -Dmaven.test.skip=true

  • 上传ROOT.war到/usr/local/tomcat/webapps/目录下。

• 第四步：浏览器访问 (http://192.168.253.128:9000/findAll)

Docker：安装Nginx容器

操作步骤

• 第一步：拉取镜像

  # 拉取nginx镜像 
  docker pull nginx
  

• 第二步：创建容器

  # 创建nginx容器 
  docker run -di --name=mynginx -p 80:80 nginx
  
  # 查看日志
  docker logs -f mynginx
  

• 第三步：测试访问(启动后再宿主机上访问: http://宿主机IP/)
  

• 第四步：配置反向代理，官方的nginx镜像，配置文件nginx.conf 在/etc/nginx/目录下。

  • 从mynginx容器拷贝配置文件到宿主机

    docker cp mynginx:/etc/nginx/nginx.conf nginx.conf
    

  • 查看mytomcat容器的ip地址

    docker inspect mytomcat
    

    
  • 配置nginx.conf

    server {
    	listen 80;
    	server_name 127.0.0.1;
    
    	location / {
    	    proxy_pass http://172.17.0.2:8080;
    	}
    } 
    

  • 将修改后的配置文件拷贝到容器中

    docker cp nginx.conf mynginx:/etc/nginx/nginx.conf
    

  • 重新启动容器

    docker restart mynginx
    

• 第五步：访问(http://宿主机IP地址/findAll)

Docker：安装Redis容器

操作步骤

• 第一步：拉取镜像

  # 拉取redis镜像
  docker pull redis
  

• 第二步：创建容器

  # 创建redis容器
  docker run -di --name=myredis -p 6379:6379 redis
  
   # 查看redis日志
  docker logs -f myredis 
  

• 第三步：操作redis容器

  # 进入redis容器
  docker exec -it myredis /bin/bash 
  
  # 进入redis安装目录 
  cd /usr/local/bin
  
  # 连接redis 
  ./redis-cli
  

• 第四步：外部代码使用redis。

  spring:
    datasource:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://172.17.0.4:3306/springboot_db
      username: root
      password: root
    redis:
      host: 192.168.253.128 # 开发环境使用宿主机ip端口，若是部署到同一台宿主机下，可使用容器的ip端口
      port: 6379
  

Docker：安装Rabbitmq容器

操作步骤

• 第一步：拉取镜像

  # 拉取rabbitmq镜像
  docker pull rabbitmq:management
  

• 第二步：创建容器

  # 创建Rabbitmq容器
  # 创建容器，rabbitmq需要有映射以下端口:
  # 15672: web管理的端口
  # 5672：(客户端连接端口)
  docker run -di --name=myrabbitmq  -p 5672:5672 -p 15672:15672 rabbitmq:management
  
   # 查看日志
  docker logs -f myrabbit
  

• 第三步：访问rabbit控制台: http://192.168.253.128:15672

Docker：容器备份与迁移

主要作用: 就是让配置好的容器，可以得到复用，后面用到得的时候就不需要重新配置。

其中涉及到的命令有:

• docker commit 将容器保存为镜像
• docker save -o 将镜像备份为tar文件
• docker load -i 根据tar文件恢复为镜像

操作步骤

• 容器保存为镜像 (使用docker commit命令可以将容器保存为镜像)。
  命令格式: docker commit 容器名称 新的镜像名称

  # 将容器保存为镜像
  # mynginx：容器名称、mynginx：新的镜像名称
  docker commit mynginx mynginx
  

  说明: 此镜像的内容就是当前容器的内容，接下来你可以用此镜像再次运行新的容器.

• 镜像备份 (使用docker save命令可以将已有镜像保存为tar文件)
  命令格式: docker save –o tar文件名 镜像名

  # 保存镜像为文件 
  docker save -o mynginx.tar mynginx
  

• 镜像恢复与迁移 (使用docker load命令可以根据tar文件恢复为docker镜像)
  命令格式: docker load -i tar文件名

  # 停止mynginx容器 
  docker stop mynginx
  
  # 删除mynginx容器 
  docker rm mynginx 
  
  # 删除mynginx镜像 
  docker rmi mynginx 
  
  # 加载恢复mynginx镜像 
  docker load -i mynginx.tar 
  
  # 在镜像恢复之后，基于该镜像再次创建启动容器 
  docker run -di --name=mynginx -p 80:80 mynginx
  

总结

• 容器保存镜像: docker commit 容器名称 新的镜像的名称
• 导出镜像: docker save -o 镜像名称.tar 新的镜像的名称
• 导入镜像: docker load -i 镜像名称.tar

Docker：Dockerfile构建镜像

Dockerfile文件

• 前面的课程中已经知道了，要获得镜像，可以从Docker仓库中进行下载。那如果我们想自己开发一个镜像，那该如何做呢？答案是: Dockerfile
• Dockerfile其实就是一个文本文件，由一系列命令和参数构成，Docker可以读取Dockerfile文件并根据Dockerfile文件的描述来构建镜像。
• Dockerfile文件内容一般分为4部分
  + 基础镜像信息
  + 维护者信息
  + 镜像操作指令
  + 容器启动时执行的指令

常用命令

命令	作用
FROM image_name:tag	定义了使用哪个基础镜像启动构建流程
MAINTAINER user_name	声明镜像的创建者
ENV key value	设置环境变量 (可以写多条)
RUN command	是Dockerfile的核心部分(可以写多条)
ADD source_dir/file dest_dir/file	将宿主机的文件复制到镜像创建的容器内，如果是一个压缩文件，将会在复制后自动解压
COPY source_dir/file dest_dir/file	和ADD相似，但是如果有压缩文件并不能解压
WORKDIR path_dir	设置工作目录

构建镜像

# 1、创建目录 
mkdir -p /usr/local/dockerjdk8 
cd /usr/local/dockerjdk8 

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

# 3、在/usr/local/dockerjdk8目录下创建Dockerfile文件，文件内容如下:
vi Dockerfile

FROM centos:7
MAINTAINER ITCAST
WORKDIR /usr
RUN mkdir /usr/local/java
ADD jdk-8u171-linux-x64.tar.gz /usr/local/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、执行命令构建镜像；不要忘了后面的那个 . （点代表当前目录）
# -t 指定镜像名称
docker build -t='jdk1.8' .

# 5、查看镜像是否建立完成 
docker images

说明: 创建文件Dockerfile 这里的D必须大写，不能有任何的偏差。

根据镜像创建容器

• 基于刚刚创建的镜像 jdk1.8 创建并启动容器进行测试

  # 创建并启动容器 
  docker run -it --name=testjdk jdk1.8 /bin/bash
  # 在容器中测试jdk是否已经安装 
  java -version
  

Docker：registry私服仓库

私有仓库搭建与配置

• Docker官方的Docker hub（https://hub.docker.com）是一个用于管理公共镜像的仓库，我们可以从上面拉取镜像到本地，也可以把我们自己的镜像推送上去。但是，有时候我们的服务器无法访问互联网，或者你不希望将自己的镜像放到公网当中，那么我们就需要搭建自己的私有仓库来存储和管理自己的镜像。

• 私有仓库搭建步骤:

  # 1、拉取私有仓库镜像 
  docker pull registry
  
  # 2、启动私有仓库容器
  docker run -di --name=registry -p 5000:5000 registry 
  
  # 3、打开浏览器 输入地址http://宿主机ip:5000/v2/_catalog，看到{"repositories":[]} 表示私有仓库 搭建成功 
  
  # 4、假设现在是另一台服务器，修改daemon.json
  vi /etc/docker/daemon.json
  
  # 在上述文件中添加一个key，保存退出。此步用于让 docker 信任私有仓库地址；注意将宿主机ip修改为自己宿主 机真实ip 
  {"insecure-registries":["宿主机ip:5000"]} 
  
  # 5、重启docker 服务 
  systemctl restart docker 
  
  # 因为现在只有一台服务器，我们重启了docker把registry容器也停掉了，因此我们启动下registry容器
  docker start registry
  

访问: http://192.168.253.128:5000/v2/_catalog

将镜像上传至私有仓库

# 1、标记镜像为私有仓库的镜像 
# 语法: docker tag jdk1.8 宿主机IP:5000/jdk1.8
docker tag jdk1.8 192.168.253.128:5000/jdk1.8


# 2、上传标记的镜像到私有仓库
# 语法: docker push 宿主机IP:5000/jdk1.8 
docker push 192.168.253.128:5000/jdk1.8

# 3、输入网址查看仓库效果

从私有仓库拉取镜像

若是在私有仓库所在的服务器上去拉取镜像；那么直接执行如下命令:

# 因为私有仓库所在的服务器上已经存在相关镜像；所以先删除；请指定镜像名，不是id 
# 语法: docker rmi 服务器ip:5000/jdk1.8
docker rmi 192.168.253.128:5000/jdk1.8

# 拉取镜像 
# 语法: docker pull 服务器ip:5000/jdk1.8
docker pull 192.168.253.128:5000/jdk1.8

#可以通过如下命令查看 docker 的信息；了解到私有仓库地址 
docker info