实用篇-Docker容器

一、初识Docker

docker 是一个开源的应用容器引擎，一个容器可以理解成一个轻量级的虚拟机，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows操作系统的机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口

简单来说，docker就是一个容器，开发者可以将自己的项目代码，以及项目的环境打包发布成为一个镜像，这个镜像是可以移植的，也就是说，我将本地的项目，运行环境打包成一个镜像发布后。在另外一台电脑或者是操作系统上是可以拉取这个镜像，拉取到镜像后用这个镜像创建运行容器就好了，这个运行起来的容器可以看做是一个微型的服务器。而沙箱机制又可以为docker容器提供完全独立的运行环境，相互之间不会互相影响，那么我就可以创建多个容器，每个容器都可以部署一个自己的项目

我们经常会遇到这样的情况：当我们开发完一个项目，打包发给别人，别人却无法运行项目，但在本地却可以运行。于是，在别人的环境中，又配置了一下此项目所需的各种环境，耗费了大量的时间和精力。项目上线时也是如此，需要在虚拟机上搭建环境，从而部署上线，这样虽说达到了目的，但是结果却是浪费了大量的安装、配置、调试的时间

总结：

• 为了解决应用部署的不便，让应用部署更加简单方便
• 避免环境不同导致的问题
• 降低微服务阶段的学习成本，减少安装时间，聚焦核心
• 为理解实际开发中的打包发布流程打基础
  Docker如何解决依赖的兼容问题的 ?

1、允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像

2、将每个应用放到一个隔离容器去运行，避免互相干扰
什么是操作系统?

1、系统应用: 例如Ubuntu、CentOS。用于封装内核指令为函数，便于程序员调用

2、内核: 负责与硬件交互，提供操作硬件的指令

3、硬件: 计算机系统的物理部分，包括各种外设和内部硬件设备
Docker如何解决不同系统环境的问题?

1、将用户程序与所需要调用的系统(比如Ubuntu)函数库一起打包

2、Docker运行到不同操作系统时，直接基于打包的库函数，借助于操作系统的Linux内核来运行
Docker如何解决开发、测试、成产环境有差异的问题?

Docker镜像中包含完整运行环境，包括系统函数库，仅依赖系统的Linux内核，因此可以在任意Linux操作系统上运行
总结：Docker是一个快速交付应用、运行应用的技术

1、可以将程序及其依赖、运行环境一起打包为一个镜像，可以迁移到任意Linux操作系统

2、运行时利用沙箱机制形成隔离容器，各个应用互不干扰

3、启动、迁移都可以通过一行命令完成，方便快捷

二、Docker和虚拟机的差别

|------|--------|-------|
| 特性 | Docker | 虚拟机 |
| 性能 | 接近原生 | 性能较差 |
| 硬盘占用 | 一般为MB | 一般为GB |
| 启动 | 秒级 | 分钟级 |

总结：

docker是一个系统进程；虚拟机是在操作系统中的操作系统

docker体积小、启动速度块、性能好；虚拟机体机大、启动速度慢、性能一般

三、Docker架构

**镜像(Image)**的概念: Docker将应用程序及其所需的依赖、函数库、环境、配置等文件打包在一起，称为镜像

**容器(Container)**的概念: 镜像中的应用程序运行后形成的进程就是容器，只是Docker会给容器做隔离，对外不可见

DockerHub: DockerHub是一个Docker镜像的托管平台。这样的平台称为Docker Registry

国内也有类似于DockerHub的公开服务，比如网易云镜像服务、阿里云镜像库

Docker是一个CS架构的程序，由两部分组成:

1、服务端(server): Docker守护进程，负责处理Docker指令，管理镜像、容器

2、客户端(client): 通过命令或RestAPI向Docker服务端发送指令。可以在本地或远程向服务端发送指令

四、Docker的安装启动

企业部署一般都是采用Linux操作系统，而其中又数CentOS发行版占比最多，因此我们接下来会在CentOS下安装Docker

具体操作如下

第一步：在VMware虚拟机安装CentOS7系统，安装完成之后，使用finalshell远程软件进行远程连接

教程：实用篇-Linux-CSDN博客

然后安装yum工具，执行如下

yum install -y yum-utils \
           device-mapper-persistent-data \
           lvm2 --skip-broken

第二步: 更新本地镜像源，执行如下

# 设置docker镜像源
yum-config-manager \
    --add-repo \
    https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
    
sed -i 's/download.docker.com/mirrors.aliyun.com\/docker-ce/g' /etc/yum.repos.d/docker-ce.repo

yum makecache fast

第三步: 执行如下安装docker，稍等片刻，docker即可安装成功。docker-ce为社区免费版本

yum install -y docker-ce

第四步: 由于Docker应用需要用到各种端口，逐一去修改防火墙设置，会非常麻烦，所以学习期间直接关闭防火墙即可

# 关闭
systemctl stop firewalld
# 禁止开机启动防火墙
systemctl disable firewalld

关闭防火墙后，可以看一下防火墙状态，是否真的关闭了

# 查看防火墙状态
systemctl status firewalld

第五步: 通过命令启动docker

systemctl start docker    # 启动docker服务

systemctl stop docker     # 停止docker服务

systemctl restart docker  # 重启docker服务

systemctl status docker   # 查看docker的启动状态

docker -v  # 查看docker版本

第六步: 配置docker镜像仓库，设置为国内的镜像仓库(这里用阿里云)，以后在docker里面下载东西的时候速度会更快。分别执行如下命令

sudo mkdir -p /etc/docker       # 创建文件夹

sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://93we6x1g.mirror.aliyuncs.com"]
}
EOF                             # 在刚刚创建的文件夹里面新建daemon.json文件，并写入花括号里面的数据

然后重新加载文件，重启docker

sudo systemctl daemon-reload    # 重新加载daemon.json文件
sudo systemctl restart docker   # 重启docker

到此，我们docker的安装和配置镜像加速就都完成了

五、Docker-镜像命令

镜像名称一般分两部分组成: [repository]:[tag]

如果没有指定tag，默认是latest，代表最新版本的镜像

在docker完成镜像的操作

例如获取镜像，有两种获取方法，第一种是本地build获取，另一种是从Docker Registry服务器里面pull拉取(更多的是这种方式)

例如分享镜像，有两种分享方法，第一种是push推送到Docker Registry服务器里面，另一种是save压缩成一个文件分享给别人，如果别人拿到你分享给Ta的压缩文件，然后别人就可以使用load命令，把压缩文件变为镜像

1. 拉取和查看镜像

案例:

从DockerHub拉取一个nginx镜像并查看，操作过程如下

第一步: 打开DockerHub官网Docker，搜索nginx，点击你想要的那个镜像，进入之后屏幕右侧有一条拉取的命令，可以直接复制

第二步: 执行你复制的那条命令，作用是拉取远程的nginx镜像到本地(如果拉去失败就重启一下docker服务)

docker pull nginx

第三步: 查看一下，是否正常拉取到nginx镜像

docker images

2. 导出已拉取的镜像

在上面，我们在docker容器里面，成功拉取到nginx镜像，那如何把这个拉取到的nginx镜像导出到磁盘保存呢，如下

docker images -o 导出后的压缩包名 要导出的镜像名称

3. 导入镜像到docker

前提: 有一个压缩包，这个压缩包是之前被导出的镜像，导出之后就变成压缩包，我们现在就是要把这个压缩包重新导入到docker容器里面

由于我们现在的docker容器里面已经有nginx镜像，所以为了这个实验，我们就可以把原有的nginx镜像删掉

docker rmi 镜像名称或镜像id

然后就可以进行导入了，如下

docker load -i 压缩包名

**4.**镜像命令练习

去DockerHub搜索并拉取一个Redis镜像
1、去DockerHub搜索Redis镜像
2、查看Redis镜像的名称和版本
3、利用docker pull命令拉取镜像
4、利用docker save命令将redis:latest打包为一个redis.tar包
5、利用docker rmi删除本地的redis:latest
6、利用docker load重新加载redis.tar文件

六、Docker-容器命令

Docker是一个大容器，里面可以划分多个相互隔离的小容器，分别运行各自的服务。运行某个服务的前提是，在Docker大容器里面先要有这个服务的镜像，然后我们根据镜像创建小容器，小容器里面就会运行镜像对应的服务。前面学的是创建Docker大容器、拉取镜像，下面学的就是如何把这些镜像创建成小容器以至于在小容器里面运行镜像对应的服务

1. 创建运行Nginx的容器

第一步: 打开DockerHub官网https://hub.docker.com/，搜索nginx，点击你想要的那个镜像，进入之后下滑即可找到使用方法

我们从官网找到这样一条可以在docker容器中去运行nginx的命令

docker run --name some-nginx -d -p 8080:80 some-content-nginx
# docker run: 创建并运行容器
# --name: 给容器起一个名字，例如叫some-nginx
# -p: 将宿主机端口与容器端口映射，冒号左侧是宿主机(例如CentOS7系统端口，右侧是容器(例如Docker容器)端口
# -d: 后台运行容器
# some-content-nginx: 镜像名称(不写tag标签就表示最新版本的镜像)

具体操作: 打开终端，输出如下

docker run --name mynginx -d -p 80:80 nginx

2. 查看Nginx运行的日志

上面我们在Docker容器里面创建了一个小容器，去运行了Nginx服务，我们还可以通过下面的命令查看Nginx服务的日志信息

docker logs Nginx服务的容器名

加上-f表示实时监控日志信息

docker logs -f Nginx服务的容器名

3. 停止/开启Nginx容器的运行

停止容器

docker stop 容器名称

开启容器

docker start 容器名称

4. 在Nginx容器里修改文件

案例: 进入Nginx容器，修改HTML文件内容，添加 "猫克塞"

第一步: 进入容器。进入我们刚刚创建的nginx容器，命令如下

docker exec -it mynginx bash
# docker exec -it [容器名称] [要执行的命令]
# docker exec: 进入容器内部，执行一个命令
# -it: 给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互
# mynginx: 要进入的容器名称，例如我们当前Nginx服务所在的容器名称就是mn
# bash: 进入容器后执行的命令，bash是一个linux终端交互命令

第二步：进入index.html静态文件

cd /usr/share/nginx/html

第三步: 修改nginx的index文件时，常见的linux的vi命令是失效的，我们想要修改文件，需要使用的是sed命令，对指定文字进行替换即可

sed -i 's#Welcome to nginx#猫克塞#g' index.html
sed -i 's#<head>#<head><meta charset="utf-8">#g' index.html

第三步: 退出nginx容器，也就是从这个小终端里面退出来

exit

第四步: 查看容器(指的是docker大容器里面的小容器)运行状态

docker ps

第五步：查看所有容器的运行状态，包括被停止的容器

5. 删除Nginx容器

docker rm -f 要删除的容器名称

6. 创建运行Redis的容器

创建运行Redis的容器，并且支持数据持久化

第一步: 由于我们前面已经在docker大容器里面有redis镜像了，所以直接使用在docker容器里面使用run创建并运行redis容器即可

docker run --name myredis -p 6379:6379 -d redis --appendonly yes
# docker run: 运行Docker容器的命令
# --name myredis : 指定容器的名称为myredis 
# -p 6379:6379: 将Redis服务器的端口6379映射到Docker主机的端口6379上。如果不进行端口映射，外部无法访问Redis服务器
# -d: 后台运行容器
# redis: 指定要运行的镜像名称(必须是已经拉取到本地的)，不知道版本的话默认是最新版本
# --appendonly yes: 开启Redis持久化功能

第二步: 进入刚刚创建的redis容器，容器名称是mr，然后使用redis-cli命令打开redis客户端，并尝试进行一些redis命令操作

docker exec -it myredis bash
# docker exec -it [容器名称] [要执行的命令]
# docker exec: 进入容器内部，执行一个命令
# -it: 给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互
# myredis: 要进入的容器名称，例如我们当前Redis服务所在的容器名称就是mr
# bash: 进入容器后执行的命令，bash是一个linux终端交互命令

连接redis客户端

redis-cli

设置key 和 value

set name keke

可以看到本地连接的192.168.229.128的redis成功显示出刚才存储的数据

七、Docker-数据卷命令

为什么需要在docker里面使用数据卷？，其实是为了解决容器与数据耦合的问题

容器的维护升级、删除伴随着容器中数据的消亡，这就使得数据不可复用，耦合性太高，给部署带来很多不便

数据卷(volume): 是一个虚拟目录，指向宿主机(也就是Docker大容器，通常叫Docker主机)文件系统中的某个真实目录。宿主机和数据卷的关系如下

数据卷操作的基本语法

docker volume [command]

docker volume命令是数据卷操作，其中command可以是以下取值

docker volume命令是数据卷操作，其中command可以是以下取值

1. 创建数据卷

创建一个数据卷，数据卷名称是html，并查看数据卷在宿主机的目录位置

docker volume create html
docker volume ls
docker volume inspect html

2. 删除数据卷

例如删除名称为html的数据卷

docker volume rm html

3. 数据卷挂载到容器

我们在上面创建容器(例如Nginx容器)时，可以通过-v参数来挂载一个数据卷到某个容器目录

docker run --name mynginx -v html:/root/html -p 80:80 nginx
# docker run: 创建并运行容器
# --name: 给容器起一个名字叫mn
# -v: 把名称为html的数据卷挂载到容器内的/root/html目录中
# -mynginx: 把宿主机的80端口映射到容器内的80端口
# nginx: 镜像名称(不写tag标签就表示最新版本的镜像)

案例: 创建一个Nginx容器，修改容器内的html目录内的index.html内容

特点: 修改不是前面学的进入容器里面进行修改，而是在数据卷挂载的目录来修改，不需要进入容器即可修改

第一步: 创建容器并挂载数据卷到容器内的html目录

docker run --name mynginx -p 80:80 -v html:/usr/share/nginx/html -d nginx

第二步: 进入mynginx容器的挂载点，进行修改文件

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

进入目录之后，就可以自由修改里面的文件，修改之后(可以vi命令修改，也可以vscode本地打开)会自动同步到容器里面

补充：当我们创建容器时，没有提前创建某个数据卷的时候，docker会自动帮我们去创建，可以安装以下命令演示一下

docker rm -f mn # 删除mn容器
docker volume rm html # 删除html数据卷
docker volume ls # 查看有哪些数据卷
docker run --name mynginx -p 80:80 -v html:/usr/share/nginx/html -d nginx # 重新创建mn容器，会自动创建html数据卷

4. 宿主机目录挂载到容器

除了数据卷可以挂载到容器，宿主机也可以直接挂载到容器。挂载方式也是通过-v参数

-v [宿主机目录]:[容器内目录]
-v [宿主机文件]:[容器内文件]

5. 两种挂载方式的对比

到此，我们在数据卷命令中，共学习了两种挂载方式，分别是 '数据卷挂载到容器'、'宿主机目录挂载到容器'。总结一下，如下

'数据卷挂载到容器' 的特点

1、即使不存在某个数据卷，但是只要我们在使用镜像创建容器时，使用-v参数去指定要把容器挂载到哪个数据卷后，docker会自动帮我们创建数据卷

2、不用关心数据卷对应的是宿主机的哪个文件层级

3、数据卷在宿主机的文件层级比较深，不好找

4、耦合度低

'宿主机目录挂载到容器'的特点

1、先手动在宿主机(也叫Docker大容器、Docker主机、或者直接理解为linux系统)里面新建某个目录

2、然后在使用镜像创建容器时，使用-v参数，把建好的目录挂载到某个'容器的目录'

3、由于目录是自己创建的，所以比较好找，更好的去修改文件，修改之后同样会自动同步到对应容器

4、耦合度高

八、Docker-自定义镜像

上面在docker中，创建容器所使用到的镜像是官方提供的，但是，我们以后学习的微服务时，不可能去使用官方提供的镜像，为了业务需求和代码安全，更多的是自己自定义镜像，因此我们将学习如何基于Dockerfile来自定义镜像，下面的学习顺序是镜像结构->Dockerfile语法->把java项目构建成一个镜像

1. 镜像结构

镜像: 是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。镜像结构图示如下，看的时候从下到上

2. Dockerfile构建镜像01

Dockerfile就是一个文本文件，其中包含一个个的指令，用指令来说明要执行什么操作来构建镜像。每一个指令都会形成一层(Layer)

|------------|----------------------------|-----------------------------|
| 指令 | 说明 | 示例 |
| FROM | 指定基础镜像 | FROM centos:6 |
| ENV | 设置环境变量，可在后面指令使用 | ENV key value |
| COPY | 拷贝本地文件到镜像的指定目录 | COPY ./mysql-5.7.rpm /tmp |
| RUN | 执行Linux的shell命令，一般是安装过程的命令 | RUN yum install gcc |
| EXPOSE | 指定容器运行时监听的端口，是给镜像使用者看的 | EXPOSE 8080 |
| ENTRYPOINT | 镜像中应用的启动命令，容器运行时调用 | ENTRYPOINT java -jar xx.jar |

Dockerfile文件示例如下

# 指定基础镜像
FROM ubuntu:16.04
# 配置环境变量，JDK的安装目录
ENV JAVA_DIR=/usr/local

# 拷贝jdk和java项目的包
COPY ./jdk8.tar.gz $JAVA_DIR/
COPY ./docker-demo.jar /tmp/app.jar

# 安装JDK
RUN cd $JAVA_DIR \
 && tar -xf ./jdk8.tar.gz \
 && mv ./jdk1.8.0_144 ./java8

# 配置环境变量
ENV JAVA_HOME=$JAVA_DIR/java8
ENV PATH=$PATH:$JAVA_HOME/bin

# 暴露端口
EXPOSE 8090
# 入口，java项目的启动命令
ENTRYPOINT java -jar /tmp/app.jar

案例: 基于Ubuntu镜像构建一个新镜像，运行一个java项目

第一步: 在/root目录，创建docker-demo目录

把docker-demo.jar、Dockerfile、jdk8.tar.gz文件复制到docker-demo目录

docker-demo.jar文件快速下载: https://cowtransfer.com/s/f20abc3b209647
Dockerfile文件快速下载: https://cowtransfer.com/s/c386b3b514a746
jdk8.tar.gz文件快速下载: https://cowtransfer.com/s/79829a22c6434f

下面就可以利用dockerfile构建镜像了

第二步: 根据Dockerfile(也就是上面的Dockerfile文件示例里面的内容)来构建镜像，镜像名称为javaweb，版本号为1.0 命令中最后一个 . 表示跟dockerfile在一个目录下

docker build -t javaweb:1.0 .
# docker build -t [自定义镜像名称]:[自定义版本号] .

第三步: 查看名称为javaweb的镜像是否构建成功

docker images

第四步: 在docker，使用这个javaweb镜像来创建名称为web的容器

docker run --name web -p 8090:8090 -d javaweb:1.0
# docker run: 创建并运行容器
# --name: 给容器起一个名字，例如叫web
# -p: 将宿主机端口与容器端口映射，冒号左侧是宿主机，右侧是容器端口
# -d: 后台运行容器
# javaweb: 镜像名称(有版本的话，必须要写版本)

第五步: 试一下浏览器能访问这个名称为web的容器吗，访问http://192.168.229.128:8090/hello/count

这就说明，dockerfile成功的构建了镜像，并且部署到docker容器了

第六步: 为不影响下面的构建镜像，我们把本实验的名称为web的容器关闭。要开的话，把stop改为start即可

3. Dockerfile构建镜像02

上面是用Dockerfile，并基于Ubuntu镜像构建一个新镜像，在新镜像里我们还创建了一个叫web的容器来运行java项目，但是有个问题就是基于Ubuntu太麻烦了，在构建过程中要执行Dockerfile文件里面的很多命令，在众多命令中，我们可以简化这些命令，避免多余命令。如下案例

案例: 基于java:8-alpine镜像，将一个java项目构建为镜像

优点: java:8-alpine镜像已经内置了jdk，也就是说我们再构建新镜像时，在Dockerfile文件可以去掉有关jdk的命令

第一步: 我们把Dockerfile文件修改为如下

# 指定基础镜像
FROM java:8-alpine

COPY ./docker-demo.jar /tmp/app.jar

# 暴露端口
EXPOSE 8090
# 入口，java项目的启动命令
ENTRYPOINT java -jar /tmp/app.jar

第二步: 根据Dockerfile(也就是上面的Dockerfile文件示例里面的内容)来构建镜像，镜像名称为javaweb，版本号为2.0。注意1.0已经在之前用过了，所以2.0

docker build -t javaweb:2.0 .
# docker build -t [自定义镜像名称]:[自定义版本号] .

第三步: 查看名称为javaweb、版本为2.0的镜像是否构建成功

docker images

第四步: 在docker，使用这个javaweb镜像来创建名称为web的容器

docker run --name web02 -p 8090:8090 -d javaweb:2.0
# docker run: 创建并运行容器
# --name: 给容器起一个名字，例如叫web02
# -p: 将宿主机端口与容器端口映射，冒号左侧是宿主机，右侧是容器端口
# -d: 后台运行容器
# javaweb: 镜像名称(有版本的话，必须要写版本)

第五步: 试一下浏览器能访问这个名称为web的容器吗，访问http://192.168.229.128:8090/hello/count

也出现了页面

九、DockerCompose-集群

1. 初识DockerCompose

在上面的 '8. Docker-自定义镜像' ，使用的是用Dockerfile文件帮我们部署单个项目，下面开始学习如何部署多个项目

1、Docker Compose可以基于Compose文件帮我们快速部署分布式应用，而无需手动一个个创建和运行容器

2、Compose文件是一个文本文件，通过指令定义集群中的每个容器如何运行

3、可以理解为Compose文件其实就是多个Dockerfile文件的集合

初始化Compose的具体操作如下

第一步: 把docker-compose文件上传到CentOS7的 /usr/local/bin 目录下

docker-compose文件快速下载链接: https://cowtransfer.com/s/4164b22290674b

第二步: 修改docker-compose文件的权限

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

第三步: 配置base自动补全命令，相当于命令提示

先执行: echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts
再执行: curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

第四步: 到此，Compose就安装好了，也就是初始化好了，下面会学如何用Compose来快速构建和部署集群

2. 部署微服务集群

如何把我们在idea写好的cloud-demo微服务项目集群，在docker里面用DockerComponent来部署。为方便大家部署，cloud-demo微服务项目的下载链接如下，建议直接用我提供的这个，下载之后解压到Windows，等下我们会传到CentOS7，现在先下载到Windows

cloud-demo项目源码快速下载: https://cowtransfer.com/s/776cb02e893b4a

第一步: 解压cloud-demo.zip，使用VScode软件打开解压后cloud-demo文件夹的docker-compose.yml文件，查看即可

第二步: 你的docker容器里的mysql密码必须要是123，如果不是的话，解决方法如下

在docker大容器(也叫docker主机、宿主机)删除mysql镜像创建好的mysql容器，重新创建一次mysql容器，创建时的密码写成123

docker stop mysql
docker rm -f mysql
cd /tmp/mysql/conf/ #进来conf目录之后，把里面唯一一个hmy.cnf文件删掉，然后重新从Windows传一个hmy.cnf文件到conf目录
cd /tmp/mysql/data/ #进来data目录之后，把里面的所有文件都删掉

# 做好清理缓存的工作之后，重新创建一次mysql容器即可
docker run --name mysql \
-e MYSQL_ROOT_PASSWORD=123 \
-p 3306:3306 \
-v /tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf \
-v /tmp/mysql/data:/var/lib/mysql \
-d \
mysql:5.7.25

第三步: 将cloud-demo项目(文件夹)上传到CentOS7的/root目录

第四步: 使用第1节 '初始化Compose' 的docker-compose文件，进行部署cloud-demo项目，先进入cloud-demo目录

docker-compose up -d

第五步: 查看容器的运行状态，会发现我们已经创建了多个容器，不再是一个个容器来创建。然后查看容器运行的日志

docker ps

第六步: 上面那一步会因为nacos启动比较慢导致微服务往nacos注册时发生错误，导致最后报错。解决: 重启相关的所有微服务

重启之后，再次查看容器运行的日志(可以查看所有容器，也可以只查看userservice容器)

docker-compose restart gateway userservice orderservice

docker-compose logs -f userservice #只查看userservice容器的日志，那么gateway、orderservice容器的日志信息是查看不到

docker-compose logs -f #查看所有容器的日志，目前我们有userservice、gateway、orderservice容器

第七步: 测试。浏览器访问。例如访问如下

http://你的CentOS7ip地址:10010/user/3?authorization=admin，例如如下
http://192.168.127.180:10010/user/3?authorization=admin

到这里，我们用dockercompose部署服务集群就完成了

**十、**Docker镜像仓库

管理镜像的仓库就叫做镜像仓库

镜像仓库 (Docker Registry) 有公共的和私有的两种形式

公共仓库: 例如Docker官方的Docker Hub，国内也与一些云服务商提供类似于DockerHub的公开服务，比如网易云镜像服务、DaoCloud镜像服务、阿里云镜像服务等

私有仓库: 自己在本地搭建私有镜像仓库。企业自己的镜像最好是采用私有镜像仓库来实现

搭建私有镜像仓库

第一步: 配置Docker信任地址

我们的私服采用的是http协议，默认不被Docker信任，所以需要做一个配置：

# 打开要修改的文件
vi /etc/docker/daemon.json
# 添加内容，注意端口要和你下面第三步真正搭建的一致
"insecure-registries":["http://你的ip地址:8080"]
# 重加载
systemctl daemon-reload
# 重启docker
systemctl restart docker

第二步: 在/root目录创建一个叫registry-ui的目录，在registry-ui目录创建一个叫docker-compose.yml的文件

第三步: 在docker-compose.yml文件写入如下，作用是搭建带有图形化界面版本

version: '3.0'
services:
  registry:
    image: registry #镜像名称
    volumes: #挂载数据卷
      - ./registry-data:/var/lib/registry
  ui: #图形化界面
    image: joxit/docker-registry-ui:static
    ports:
      - 8080:80 #我们访问时的端口。这个8080端口是我们添加到信任的端口
    environment: #环境变量
      - REGISTRY_TITLE=您的私有仓库 #自定义registry服务的标题
      - REGISTRY_URL=http://registry:5000 #registry服务的地址(内部使用不暴露我们无法访问)，格式:http://服务名:端口
    depends_on:
      - registry

第四步: 进入registry-ui目录，然后执行docker-compose命令，作用是部署私有镜像仓库

docker-compose up -d

第五步: 查看部署状态

docker-compose logs -f

第六步: 浏览器访问http://你的ip:8080，例如如下

http://192.168.229.128:8080