视频学习：黑马程序员Java微服务

网盘资源：https://pan.baidu.com/s/1LxIxcHDO7SYB96SE-GZfuQ 提取码：dor4

学习路线及部分内容参考：Kyle’s Blog

初识Docker

什么是Docker

项目部署的问题

大型项目组件比较多，运行环境也较为复杂，部署时会碰到一些问题

依赖关系复杂，容易出现兼容性问题
开发、测试、生产环境有差异

解决依赖兼容问题

Docker是如何解决依赖的兼容问题的？

将应用的函数库(libs)、依赖(Deps)、配置与应用一起打包
将每个应用放到一个隔离容器去运行，避免相互干扰

上面解决了不同应用的兼容问题，但是开发、测试等环节会存在差异，操作系统版本也会有差异，这些问题又该如何解决呢？

解决操作系统环境差异

首先介绍以下操作系统结构，这里以Ubuntu操作系统为例：

计算机硬件：例如CPU、内存、磁盘等
系统内核：所有Linux发行版的内核都是Linux，例如CentOS、Ubuntu、Fedora等。内核可以与计算机硬件交互，对外提供内核指令，用于操作计算机硬件。
系统应用：操作系统本身提供的应用、函数库。这些含数据是对内核指令的封装，使用更加方便

他们之间的关系：

内核（Linux内核等）与硬件交互，提供操作硬件的指令
系统应用（Ubuntu、CentOS等）封装内核指令为函数，便于程序员调用
用户程序（mysql、node.js等）基于系统函数库实现功能

Ubuntu和CentOS都是基于Linux内核，只是系统应用不同，提供的函数库有差异。此时，如果将一个Ubuntu版本的MySQL应用安装到CentOS系统，MySQL在调用Ubuntu函数库时，会发现找不到或不匹配，就会报错。这就是操作系统环境差异所致。

Docker如何解决不同系统环境的问题？

Docker将用户程序所需要的系统(比如Ubuntu)函数库一起打包
Docker运行到不同操作系统时，直接基于打包的函数库，借助于操作系统的Linux内核来运行

小结

Docker如何解决大型项目依赖关系复杂，不同组件依赖的兼容性问题？

Docker允许开发中将应用、依赖、函数库、配置一起打包，形成可移植镜像
Docker应用运行在容器中，使用沙箱机制，相互隔离

Docker如何解决开发、测试、生产环境有差异的问题？

Docker镜像中包含完整运行环境，包括系统函数库，仅依赖系统的Linux内核，因此可以在任意Linux操作系统上运行

Docker是一个快速交付应用、运行应用的技术，具备以下优势：

可将程序及其依赖、运行环境一起打包为一个镜像，可以迁移到任意Linux操作系统
运行时利用沙箱机制形成隔离容器，各个应用互不干扰
启动、移除都可以通过一行命令完成，方便快捷

Docker和虚拟机的区别

虚拟机(virtual machine)是在操作系统中模拟硬件设备，然后运行另一个操作系统。例如在Windows系统中运行CentOS系统，就可以运行任意的CentOS应用了（这里基于Hypervisor技术）

Docker仅仅是封装函数库，并没有模拟完整的操作系统

二者对比：

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

小结：Docker和虚拟机的差异

Docker是一个系统进程；虚拟机是在操作系统中操作系统
Docker体积小、启动速度快、性能好；虚拟机体积大、启动速度慢、性能一般

Docker架构

镜像和容器

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

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

注意：镜像都是只读的（防止对镜像文件进行修改/污染，从而导致镜像不可用，容器从镜像中拷贝一份文件到自己的空间里来写数据）

DockerHub

开源应用程序非常多，打包这些应用往往都是重复性劳动，为了避免这些重复劳动，人们就会将自己打包的应用镜像，例如Redis、MySQL镜像放到网络上来共享使用，就像GitHub的代码共享一样

DockerHub是一个官方的Docker镜像的托管平台，这样的平台称为Docker Registry。
国内也有类似于DockerHub的公开服务，例如网易云镜像服务、阿里云镜像库等

Docker架构

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

服务端(server)：Docker守护进程，负责处理Docker指令，管理镜像、容器等
客户端(client)：通过命令或RestAPI向Docker服务端发送指令，可以在本地或远程向服务端发送指令

安装Docker

Docker 分为 CE 和 EE 两大版本。CE 即社区版，免费，支持周期 7 个月；EE 即企业版，强调安全，付费使用，支持周期 24 个月。

Docker CE 分为 stable test 和 nightly 三个更新频道。

官方网站上有各种环境下的安装指南，这里主要介绍 Docker CE 在 CentOS上的安装。

Docker CE 支持 64 位版本 CentOS 7，并且要求内核版本不低于 3.10。CentOS 7满足最低内核要求，本文也是在CentOS 7安装Docker

卸载

如果之前安装过旧版本的Docker，可以使用下面命令卸载

yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine \
                  docker-ce

安装Docker

首先先安装yum工具

1
2
3

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

1	yum install -y docker-ce

启动Docker

Docker应用需要用到各种端口，挨个修改防火墙设置很麻烦，所以这里建议直接关闭防火墙

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

通过命令启动Docker

# 启动docker服务
systemctl start docker 

# 停止docker服务
systemctl stop docker

# 重启docker服务
systemctl restart docker

查看docker启动状态：

1	systemctl status docker

输出：

[root@localhost ~]# systemctl status docker
● docker.service - Docker Application Container Engine
   Loaded: loaded (/usr/lib/systemd/system/docker.service; disabled; vendor preset: disabled)
   Active: active (running) since 五 2023-08-04 21:24:52 CST; 33s ago
     Docs: https://docs.docker.com
 Main PID: 23723 (dockerd)
    Tasks: 8
   Memory: 27.3M
   CGroup: /system.slice/docker.service
           └─23723 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

8月 04 21:24:51 localhost.localdomain systemd[1]: Starting Docker Application Container Engine...
8月 04 21:24:51 localhost.localdomain dockerd[23723]: time="2023-08-04T21:24:51.686785766+08:00" level=info ms... up"
8月 04 21:24:51 localhost.localdomain dockerd[23723]: time="2023-08-04T21:24:51.711614577+08:00" level=info ms...rt."
8月 04 21:24:52 localhost.localdomain dockerd[23723]: time="2023-08-04T21:24:52.017474188+08:00" level=info ms...ne."
8月 04 21:24:52 localhost.localdomain dockerd[23723]: time="2023-08-04T21:24:52.097897087+08:00" level=info ms....0.5
8月 04 21:24:52 localhost.localdomain dockerd[23723]: time="2023-08-04T21:24:52.098561948+08:00" level=info ms...ion"
8月 04 21:24:52 localhost.localdomain dockerd[23723]: time="2023-08-04T21:24:52.140142496+08:00" level=info ms...ock"
8月 04 21:24:52 localhost.localdomain systemd[1]: Started Docker Application Container Engine.
Hint: Some lines were ellipsized, use -l to show in full.

查看docker版本

docker -v

输出：

1 2	[root@localhost ~]# docker -v Docker version 24.0.5, build ced0996

配置镜像加速

Docker官方镜像库网速较差，我们需要设置为国内镜像服务，参考阿里云的镜像加速文档：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

只要输入以下命令即可：(这里是新建一个配置文件，向其中写入镜像仓库)

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

Docker的基本操作

镜像操作

镜像名称一般分为两部分：[repository]:[tag]

例如mysql:5.7，这里的mysql就是repository，5.7就是tag，合在一起就是镜像名称，代表5.7版本的MySQL镜像

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

镜像命令

常见命令如下：

可以使用命令docker --help查看docker的帮助文档

Usage:  docker [OPTIONS] COMMAND

A self-sufficient runtime for containers

Common Commands:
  run         Create and run a new container from an image
  exec        Execute a command in a running container
  ps          List containers
  build       Build an image from a Dockerfile
  pull        Download an image from a registry
  push        Upload an image to a registry
  images      List images
  ……

如果查看具体的某个命令使用方法，可以使用：docker images --help查看具体用法

Usage:  docker images [OPTIONS] [REPOSITORY[:TAG]]

List images

Aliases:
  docker image ls, docker image list, docker images

Options:
  -a, --all             Show all images (default hides intermediate images)
      --digests         Show digests
  -f, --filter filter   Filter output based on conditions provided
      --format string   Format output using a custom template:
  ……

使用案例

需求1：从DockerHub中拉取一个Nginx镜像并查看

首先去镜像仓库搜索nginx镜像，比如DockerHub

然后使用docker pull nginx拉取最新的nginx镜像

[root@localhost ~]# docker pull nginx
Using default tag: latest
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete 
a9edb18cadd1: Pull complete 
589b7251471a: Pull complete 
186b1aaa4aa6: Pull complete 
b4df32aa5a72: Pull complete 
a0bcbecc962e: Pull complete 
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest

通过命令docker images查看拉取到的镜像

1
2
3

[root@localhost ~]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
nginx        latest    605c77e624dd   19 months ago   141MB

需求2：利用docker save将nginx镜像导出磁盘，然后在通过docker load加载回来

首先查看save的用法

Usage:  docker save [OPTIONS] IMAGE [IMAGE...]

Save one or more images to a tar archive (streamed to STDOUT by default)

Aliases:
  docker image save, docker save

Options:
  -o, --output string   Write to a file, instead of STDOUT

可以看出命令格式：

1	docker save -o [保存的目标文件名称] [镜像名称]

这里我们就是：docker save -o nginx.tar nginx:latest

在使用docker load加载镜像之前，需要使用命令删除之前的本地nginx镜像
1
docker rmi nginx:latest
rmi是remove image的缩写

然后查看load用法

Usage:  docker load [OPTIONS]

Load an image from a tar archive or STDIN

Aliases:
  docker image load, docker load

Options:
  -i, --input string   Read from tar archive file, instead of STDIN
  -q, --quiet          Suppress the load output

命令格式：

1	docker load -i [镜像压缩文件名]

这里我们就是：docker load -i nginx.tar

容器操作

容器命令

容器命令用法如下：

容器的三种状态：

运行：进程正常运行
暂停：进程暂停，CPU不再运行，不释放内存
- 操作系统将容器内的进程挂起，容器关联的内存暂存起来，然后CPU不再执行这个进程，但是使用unpause命令恢复，内存空间被恢复，程序继续运行。
停止：进程终止，回收进程占用的内存、CPU等资源
- 直接将进程杀死，容器所占的内存回收，保存的仅剩容器的文件系统，也就是那些静态的资源

使用案例

案例一：创建并运行一个Nginx容器

去docker hub查看Nginx的容器运行命令
1
docker run --name containerName -p 80:80 -d nginx
命令解读
- docker run：创建并运行一个容器
- --name：给容器起一个名字，比如叫做mn
- -p：将宿主机端口与容器端口映射，冒号左侧是宿主机端口，右侧是容器端口
  - 默认情况下，容器是隔离环境，直接访问宿主机的80端口，肯定访问不到容器中的nginx
  - 现在，容器的80端口和宿主机的80端口关联了起来，当我们访问宿主机的80端口时，就会被映射到容器的80端口，这样就能访问nginx了
  - 宿主机端口一般随意设定，只要没被占用；容器端口一般跟应用有关，比如Nginx是80，Nacos是8848，Tomcat是8080，Mysql是3306等
- -d：后台运行容器
- nginx：镜像名称，例如nginx

运行这个命令

1 2	[root@localhost ~]# docker run --name mn -p 80:80 -d nginx 3579a53110e6de92eda5175c54d7f190bace7cc45eb285d0629ce52423959d72

可以看到返回了一长串字符串，这是容器的唯一id

查看容器运行状态 docker ps

1
2
3

[root@localhost ~]# docker ps
CONTAINER ID   IMAGE     COMMAND                   CREATED              STATUS              PORTS                               NAMES
3579a53110e6   nginx     "/docker-entrypoint.…"   About a minute ago   Up About a minute   0.0.0.0:80->80/tcp, :::80->80/tcp   mn

访问nginx，浏览器中输入虚拟机ip:80，就可以看到以下nginx主页内容

查看容器日志：docker logs [容器名]

1
2
3

192.168.186.1 - - [05/Aug/2023:01:50:12 +0000] "GET / HTTP/1.1" 200 615 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.50" "-"
2023/08/05 01:50:12 [error] 31#31: *1 open() "/usr/share/nginx/html/favicon.ico" failed (2: No such file or directory), client: 192.168.186.1, server: localhost, request: "GET /favicon.ico HTTP/1.1", host: "192.168.186.128", referrer: "http://192.168.186.128/"
192.168.186.1 - - [05/Aug/2023:01:50:12 +0000] "GET /favicon.ico HTTP/1.1" 404 555 "http://192.168.186.128/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.50" "-"

添加参数-f可以持续输出日志：docker logs -f []

案例二：进入Nginx容器，修改HTML文件内容，添加”YSKM”

进入容器。使用docker exec

Usage:  docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

Execute a command in a running container

Aliases:
  docker container exec, docker exec

Options:
  -d, --detach               Detached mode: run command in the background
      --detach-keys string   Override the key sequence for detaching a container
  -e, --env list             Set environment variables
      --env-file list        Read in a file of environment variables
  -i, --interactive          Keep STDIN open even if not attached
      --privileged           Give extended privileges to the command
  -t, --tty                  Allocate a pseudo-TTY
  -u, --user string          Username or UID (format: "<name|uid>[:<group|gid>]")
  -w, --workdir string       Working directory inside the container

使用以上命令进入刚创建的容器：docker exec -it mn bash

命令解读

docker exec：进入容器内部，执行一个命令
-it：给当前进入的容器创建一个标准输入、输出终端，允许我们与容器交互
mn：要进入的容器名称
bash：进入容器后执行的命令，bash是一个linux终端交互命令

运行这个命令后，会发现发生了变化，前面不再是localhost了，而是容器id

1 2	[root@localhost ~]# docker exec -it mn bash root@3579a53110e6:/#

并且通过ls可以看出目录结构类似Linux文件系统

1
2
3

root@3579a53110e6:/# ls
bin   dev                  docker-entrypoint.sh  home  lib64  mnt  proc  run   srv  tmp  var
boot  docker-entrypoint.d  etc                   lib   media  opt  root  sbin  sys  usr

容器内部会模拟一个独立的Linux文件系统，看起来就如同一个linux服务器一样，nginx的环境、配置、运行文件全部都在这个文件系统中。看起来类似一样，其实是一个阉割版的，这里只有nginx运行需要的内容。

因为我们想要修改nginx的内容，但是并不知道其安装路径，只有对应作者直到，所以仍是查看Docker hub中的nginx页面，可以知道nginx的html目录位置在/usr/share/nginx/html。这里我们进入并且查看内容：
1
2
3
root@3579a53110e6:/# cd /usr/share/nginx/html
root@3579a53110e6:/usr/share/nginx/html# ls
50x.html index.html
修改index.html的内容

容器内没有vi命令，无法直接修改，使用下面的命令来修改
1
sed -i -e 's#Welcome to nginx#YSKM#g' index.html

此时访问nginx，可以看到内容已经做了修改

退出容器。使用exit命令

1
2
3

root@3579a53110e6:/usr/share/nginx/html# exit
exit
[root@localhost ~]#

停止容器：docker stop [name]

然后查看容器，默认是查看运行中的容器，后面加个参数-a可以查看所有

[root@localhost ~]# docker stop mn
mn

[root@localhost ~]# docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

[root@localhost ~]# docker ps -a
CONTAINER ID   IMAGE     COMMAND                   CREATED          STATUS                          PORTS     NAMES
3579a53110e6   nginx     "/docker-entrypoint.…"   55 minutes ago   Exited (0) About a minute ago             mn

可以看到状态显示Exit

如果想要重新启动，使用docker start mn即可，删除容器使用docker rm mn即可，但是需要停止容器，如果想要运行时删除，加上-f参数即可，即docker rm -f mn

要善用使用文档！

数据卷（容器数据管理）

容器与数据耦合的问题：

在之前的nginx案例中，修改nginx的html页面时，需要进入nginx内部，修改文件很麻烦，这就是容器与数据（容器内文件）耦合带来的后果，如果我们另外运行一台新的nginx容器，那么这台新的nginx容器也不能直接使用我们修改好的html文件，具有很多缺点

不便于修改：当我们要修改nginx的html内容时，需要进入容器内部修改，很不方便
数据不可服用：由于容器内的修改对外是不可见的，所有的修改对新创建的容器也是不可复用的
升级维护困难：数据在容器内，如果要升级容器必然删除旧容器，那么旧容器中的所有数据也跟着被删除了（包括改好的html页面）

要解决这个问题，必须将数据和容器解耦，这就要用到数据卷了

数据卷

数据卷（volume）是一个虚拟目录，指向宿主机文件系统中的某个目录

一旦完成数据卷挂载，对容器的一切操作都会作用在对应的宿主机目录了。这样操作宿主机的/var/lib/volumes/html目录，就等同于操作容器内的/usr/share/nginx/html目录了

操作数据卷

语法：

数据卷操作的基本语法如下

1	docker volume [COMMAND]

docker volume命令是数据卷操作，根据命令后跟随的command来确定下一步的操作

create：创建一个volume
inspect：显示一个或多个volume的信息
ls：列出所有的volume
prune：删除未使用的volume
rm：删除一个或多个指定的volume

创建和查看数据集

创建数据卷
1
docker volume create [name]

查看所有数据

1	docker volume ls

结果

1
2
3

[root@localhost ~]# docker volume ls
DRIVER    VOLUME NAME
local     html

查看数据卷详细信息卷

1	docker volume inspect html

结果

[root@localhost ~]# docker volume inspect html
[
    {
        "CreatedAt": "2023-08-05T16:33:35+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/volumes/html/_data",
        "Name": "html",
        "Options": null,
        "Scope": "local"
    }
]

可以看到我们创建的html这个数据卷关联的宿主机目录为/var/lib/volumes/html/_data

删除数据卷

删除所有未使用的数据卷
1
docker volume prune
删除指定数据卷
1
docker volume rm [name]

挂载数据卷

在创建容器时，可以通过-v参数来挂载一个数据卷到某个容器内目录，命令格式如下

docker run \
    -- name myNginx \
    -v html:/root/html \
    -p 8080:80 \
    nginx \

这里的-v就是挂载数据卷的命令

-v html:/root/html：把html数据卷挂载到容器内的/root/html这个目录中

示例1-数据卷挂载到容器

需求：创建一个nginx容器，修改容器内的html目录的index.html内容。上个案例中，我们进入nginx容器内部，已经知道了nginx的html目录所在位置/usr/share/nginx/html，我们需要把这个目录挂载到html这个数据卷上，方便操作其中的内容
提示：运行容器时，使用-v参数挂载数据卷

创建容器并挂载数据卷到容器内的HTML目录

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

进入html数据卷所在位置，并修改HTML内容

# 查看数据卷位置
docker volume inspect html
# 进入该目录
cd /var/lib/volumes/html/_data
# 修改文件（此时文件也能够在编译器或者浏览器中查看）
vi index.html

可以看到，(对比前面容器操作-使用案例-修改HTML)，现在原本在容器中的文件也可以在宿主机上显示，并且能够使用vim等编辑命令修改对应内容了

[root@localhost ~]# docker run --name mn -v html:/usr/share/nginx/html -p 80:80 -d nginx
106d163b4213b574c047b1bf5c9724921192f66dad6ff615b51ee2e4cb8a63ee
[root@localhost ~]# docker ps -a
CONTAINER ID   IMAGE     COMMAND                   CREATED         STATUS         PORTS                               NAMES
106d163b4213   nginx     "/docker-entrypoint.…"   3 seconds ago   Up 2 seconds   0.0.0.0:80->80/tcp, :::80->80/tcp   mn
[root@localhost ~]# docker volume inspect html
[
    {
        "CreatedAt": "2023-08-05T16:33:35+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/volumes/html/_data",
        "Name": "html",
        "Options": null,
        "Scope": "local"
    }
]
[root@localhost ~]# cd /var/lib/volumes/html/_data
[root@localhost _data]# ls
50x.html  index.html

总结：

数据卷挂载方式有两种：

可以使用参数-v volumeName:/path挂载数据卷；
如果运行容器时没有创建数据卷，而是直接使用上面的命令，docker会自动帮助我们创建数据卷。

示例2-宿主机目录挂载容器

容器不仅仅可以挂载数据卷，也可以直接挂载到宿主机目录上，关系如下

带数据卷模式：宿主机目录 —> 数据卷 —> 容器内目录
直接挂载模式：宿主机目录 —> 容器内目录

目录挂载和数据卷挂载的语法是类似的

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

需求：创建并运行一个MySQL容器，将宿主机目录直接挂载到容器

从Docker Hub上拉取mysql
1
docker pull mysql
创建目录/tmp/mysql/data
1
mkdir -p /tmp/mysql/data

创建目录/tmp/mysql/conf，将资料中的hmy.cnf文件上传到这里

1	mkdir -p /tmp/mysql/conf

hmy.cnf

[mysqld]
skip-name-resolve
character_set_server=utf8
datadir=/var/lib/mysql
server-id=1000

从Docker Hub上查阅资料，创建并运行MySQL容器，要求

挂载/tmp/mysql/data到mysql容器内数据存储目录
挂载/tmp/mysql/conf/hmy.cnf到mysql容器的配置文件

设置MySQL密码

docker run \
 --name mysql \ 
 -e MYSQL_ROOT_PASSWORD=root \           # 密码
 -v /tmp/mysql/conf:/etc/mysql/conf.d \  # 挂载配置文件目录
 -v /tmp/mysql/data:/var/lib/mysql \     # 挂载数据目录
 -p 3306:3306 \  # 端口映射
 -d \
 mysql  # mysql版本，这里默认最新

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

此时可以使用docker ps -a查看所有的容器，并且使用Navicat连接数据库，发现可以正常连接，查看到其中的表格。

并且如果停掉mysql容器docker stop mysql，数据库就打不开，说明这里实现成功

番外-端口占用

在上面的示例2中，我直接执行mysql容器的创建会报错：

docker: Error response from daemon: driver failed programming external connectivity on endpoint ms (77e753dea662698b059052caebcd9215bec7031cfb7a4b17be555be47f0f63e2): Error starting userland proxy: listen tcp4 0.0.0.0:3306: bind: address already in use.

这是因为端口占用的缘故，这里使用netstat -tanlp命令查看当前占用端口

Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      37783/docker-proxy  
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      6589/sshd           
tcp        0      0 127.0.0.1:25            0.0.0.0:*               LISTEN      6823/master         
tcp        0      0 192.168.186.128:22      192.168.186.1:3860      ESTABLISHED 85109/sshd: root@pt 
tcp        0      0 192.168.186.128:22      192.168.186.1:6572      ESTABLISHED 70068/sshd: root@no 
tcp6       0      0 :::3306                 :::*                    LISTEN      8368/mysqld         
tcp6       0      0 :::80                   :::*                    LISTEN      37790/docker-proxy

可以看到3306端口被占用，这是因为我之前就在虚拟机中安装了mysql，并且设置了开机自启动，这里直接kill掉对应的进程PID即可

总结

docker run的命令中通过-v参数挂载文件或目录到容器中

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

数据卷挂载与目录直接挂载的区别

数据卷挂载耦合度低，由docker来管理目录，但是目录较深，不好找
目录挂载耦合度高，需要我们自己管理目录，不过目录容易寻找查看

下图中，上面的虚线就是docker数据卷挂载；下面的虚线就是宿主机目录挂载

Dockerfile自定义镜像

并不是所有的镜像官方都已经做好了，我们自己写的项目仍需要自己构建镜像

镜像结构

镜像是将应用程序及其需要的系统函数库，环境、配置、依赖打包而成。以MySQL为例，来看看它的镜像组成结构

为什么需要分层结构？这里是提高复用性，节省一定的时间。比如原本的mysql5.7要升级成5.8，我们从最基础分层查看，发现大部分底层都不需要改变，更多是上层的内容，因此这样修改就更简单，提高复用性的同时节省时间。

总的来说，镜像是一个分层的结构，每一层称为一个Layer：

BaseImage层：包含基本的系统函数库、环境变量、文件系统
Entrypoint：入口，是镜像中应用启动的命令
其他，在BaseImage的基础上添加依赖、安装程序、完成整个应用的安装和配置

Dockerfile语法

Dockerfile就是一个文本文件，其中包含一个个指令(Instruction)，用指令说明要执行什么操作来构建镜像，每一个指令都会形成一层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	镜像中应用的启动命令，容器运行时调用	ENTRYPOINTjava -jar xxjar

构建Java项目

需求：基于Ubuntu镜像构建一个新镜像，运行一个Java项目

原始方式

准备工作：首先创建一个空的文件夹docker-demo：mkdir /tmp/docker-demo，然后将资料中的docker-demo.jar、jdk8.tar.gz、Dockerfile上传到这个文件夹中。

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

这里访问需要关闭防火墙；如果已经安装了jkd并且配置了环境变量，相关的内容去掉即可。

在docker-demo目录下使用docker build命令构建镜像
1
docker build -t javaweb:1.0 .
注意最后的点，与前面有一个空格

使用docker images查看镜像，发现镜像生成了

[root@localhost docker-demo]# docker images
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
javaweb      1.0       07670be0eb3d   8 seconds ago   160MB
nginx        latest    605c77e624dd   19 months ago   141MB
mysql        latest    3218b38490ce   19 months ago   516MB

创建并运行一个javaWeb容器

1	docker run --name te -p 8090:8090 -d javaweb:1.0

访问ip:8090/hello/count，即可查看页面效果

优化版本

上述项目需要安装JDK并配置环境变量，并且每次构建Java项目的镜像的时候，都需要完成这个步骤。所以为什么不找一个已经安装好了JDK的基础镜像，然后在其基础上来构建Java项目的镜像呢？这里就提到了java:8-alpine镜像，但这里需要用到openjdk:8

准备工作和上面一致，这里主要是修改Dockerfile即可。

修改Dockerfile

# 将openjdk:8作为基础镜像
FROM openjdk:8

# 拷贝java项目的包
COPY ./docker-demo.jar /tmp/app.jar

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

构建镜像
1
docker build -t javaweb:2.0 .

创建并运行一个javaweb容器

1	docker run --name test2 -p 8090:8090 -d javaweb:2.0

可以看到成功启动

1 2	CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 6cffee5c95cb javaweb:2.0 "/bin/sh -c 'java -j…" 4 seconds ago Up 2 seconds 0.0.0.0:8090->8090/tcp, :::8090->8090/tcp test2

此时访问效果跟上述一致

总结：

Dockerfile本质就是一个文件，通过指令描述镜像的构建过程
Dockerfile的第一行必须是FROM，从一个基础镜像来构建
基础镜像可以使基本操作系统，如Ubunut，也可以是其他人制作好的镜像，例如openjdk:8

Docker-Compose

初识DockerCompose

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

Compose文件是一个文本文件，通过指令定义集群中的每个容器如何运行。（可以认为Compose文件是多个docker run的集合）。示例如下：

version: "3.8"
  services:
	# 第一个容器
    mysql:  # 对应docker run中的 --name
      image: mysql:5.7.25 # 对应docker run中最后声明的镜像
      enviroment:   # 对应docker run中的 -e MYSQL_ROOT_PASSWIRD=root
        MYSQL_ROOT_PASSWORD: root
      volumes: # 对应docker run中的 -v /tmp/mysql/data:/var/lib/mysql
        - "/tmp/mysql/data:/var/lib/mysql"
        - "/tmp/mysql/conf/myCnf.cf:/etc/mysql/conf.d/myCnf.cnf"
      # 这里并不需要-d参数来后台运行，因为此种方法默认就是后台运行
      # 同时也不需要暴露端口，在微服务集群部署中，MySQL仅仅是供给给集群内的服务使用的，所以不需要对外暴露端口
	
	# 第二个容器
    web:
      build: . # 从当前目录构建镜像
      ports:
        - "8090:8090"

以上的文件中包含两个容器：mysql和web，代表了实际应用的两类案例：基于镜像直接部署；基于build构建镜像
第一个mysql容器的命令相当于：
1
docker run --name mysql -e MYSQL_ROOT_PASSWORD=root -p 3306:3306 -v /tmp/mysql/data:/var/lib/mysql -v /tmp/mysql/conf/myCnf.cf:/etc/mysql/conf.d/myCnf.cnf -d mysql:5.7.25
第二个web容器的命令相当于
1
2
docker build -t web:1.0
docker run --name web -p 8090:8090 -d web:1.0

DockerCompose的详细语法请参考官网：https://docs.docker.com/compose/compose-file/

安装DockerCompose

在Linux下使用命令下载

1 2	# 安装 curl -L https://github.com/compose/releases/download/1.29.1/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose

如果下载比较慢，可以使用课程资料中提供的docker-compose文件，上传到user/local/bin目录下

修改文件权限

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

Base自动补全命令

1	curl -L https://raw.githubusercontent.com/compose/1.29.1/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose

如出现错误Failed connect to raw.githubusercontent.com:443; Connection refused，需要修改自己的hosts文件
1
echo "199.232.68.133 raw.githubusercontent.com" >> /etc/hosts

部署微服务集群

需求：将之前学习的cloud-demo微服务集群利用DockerCompose部署

实现思路如下：

编写docker-compose文件
修改自己的cloud-demo项目，将其中的数据库、nacos地址，都重命名为docker-compose中的服务名
使用maven打包工具，将项目中的每个微服务都打包为app.jar（打包名与Dockerfile中一致即可）
将打包好的app.jar拷贝到cloud-demo中的每一个对应的子目录中，编写Dockerfile文件
将cloud-demo上传至虚拟机，利用docker-compose up -d来部署

Compose文件

version: "3.2"

services:
  nacos:
    image: nacos/nacos-server
    environment:
      MDOE: standalone
    ports:
      - "8848:8848"
      
  mysql:
    image: mysql:5.7.25
    environment:
      MYSQL_ROOT_PASSWORD: root
    volumes:
      - "$PWD/mysql/data:/var/lib/mysql"  # 这里的$PWD是执行linux命令，获取当前目录
      - "$PWD/mysql/conf:/etc/mysql/conf.d"
        
  userservice:
    build: ./user-service
      
  orderservice:
    build: ./order-service
      
  gateway:
    build: ./gateway
    poets:
      - "10010:10010"

其中包含了5个服务：

nacos：作为注册中心和配置中心

image: nacos/nacos-server：基于nacos/nacos-server镜像构建

environment: 环境变量

MODE: standalone：单点模式启动

ports：端口映射，这里暴露了8848端口

mysql：数据库

image: mysql5.7.25：基于5.7.25版本的MySQL镜像构建

environment：环境变量

MYSQL_ROOT_PASSWORD: root：设置数据库root账户密码为root

volumes：数据卷挂载，这里挂载了mysql的data和conf目录

userservice：基于Dockerfile临时构建，userservice不需要暴露端口，网关才是微服务的入口，如果暴露了userservice的端口，那么网关的身份认证，权限校验就形同虚设了

orderservice：基于Dockerfile临时构建，不需要暴露端口，理由同上

gateway：基于Dockerfile临时构建，网关需要暴露端口，它是其他微服务的入口

修改微服务配置

修改自己的cloud-demo项目，将其中的数据库、nacos地址，都重命名为docker-compose中的服务名。

因为原本的项目中访问都采用的localhost:端口实现，但是实际上这些服务不一定在同一台机器上。使用Docker Compose部署时，所有的服务之间都可以用服务名互相访问，那现在就需要修改cloud-demo中的yml配置文件

bootstrap.yml

spring:
  application:
    name: user-service # 服务名称
  cloud:
    nacos:
#      server-addr: localhost:8848 # Nacos地址
      server-addr: nacos:8848
      config:
        file-extension: yaml # 文件后缀名

application.yml（这里以user-service为例，其他的order-service和gateway都是一样，修改mysql和nacos地址）

server:
  port: 8081

spring:
  datasource:
#    url: jdbc:mysql://localhost:3306/cloud_user?useSSL=false
    url: jdbc:mysql://mysql:3306/cloud_user?useSSL=false
    username: root
    password: wzy123
    driver-class-name: com.mysql.cj.jdbc.Driver

mybatis:
  type-aliases-package: cn.itcast.user.pojo
  configuration:
    map-underscore-to-camel-case: true
logging:
  level:
    cn.itcast: debug
  pattern:
    dateformat: MM-dd HH:mm:ss:SSS

打包

使用maven打包工具，将项目中的每个微服务都打包为app.jar（打包名与Dockerfile中一致即可）

这里的build标签和dependencies标签同级；将下面的内容拷贝给所有服务的pom文件中

<build>
    <finalName>app</finalName>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

都叫app不会冲突吗？因为他们都有各自的文件夹，都在对应的target目录下

拷贝完成后首先使用maven的lifecycle中的clean，然后使用package打包。打包完成的都在target目录下

将jar包拷贝到部署目录

将打包好的app.jar拷贝到cloud-demo中的每一个对应的子目录中，编写Dockerfile文件

这里的部署项目是资料中提供的，将上述的jar包放置在相应的服务下即可。

cloud-demo
    gateway
+   	app.jar
    	Dockerfile.yml
    order-service
+   	app.jar
    	Dockerfile.yml
    user-service
+   	app.jar
   	 	Dockerfile.yml
    mysql
    	data
   	 	conf
    docker-compose.yml

其中，以上各个服务的Dockerfile内容如下：

gateway

1
2
3

FROM openjdk:8
COPY ./app.jar /tmp/app.jar
ENTERPOINT java -jar /tmp/app.jar

order-service

1
2
3

FROM openjdk:8
COPY ./app.jar /tmp/app.jar
ENTERPOINT java -jar /tmp/app.jar

user-service

1
2
3

FROM openjdk:8
COPY ./app.jar /tmp/app.jar
ENTERPOINT java -jar /tmp/app.jar

部署

将cloud-demo上传至虚拟机，进入该目录，使用docker-compose up -d来部署

……
Creating cloud-demo_userservice_1  ... done
Creating cloud-demo_nacos_1        ... done
Creating cloud-demo_gateway_1      ... done
Creating cloud-demo_orderservice_1 ... done
Creating cloud-demo_mysql_1        ... done

使用docker ps查看运行的容器

[root@localhost cloud-demo]# docker ps
CONTAINER ID   IMAGE     COMMAND     CREATED      STATUS     PORTS    NAMES
e22c88c6efa3   mysql:5.7.25              "docker-entrypoint.s…"   56 seconds ago   Up 46 seconds   3306/tcp, 33060/tcp                             cloud-demo_mysql_1

cbce84f9705b   nacos/nacos-server        "bin/docker-startup.…"   56 seconds ago   Up 46 seconds   0.0.0.0:8848->8848/tcp, :::8848->8848/tcp       cloud-demo_nacos_1

a1df81a67fe4   cloud-demo_orderservice   "/bin/sh -c 'java -j…"   56 seconds ago   Up 46 seconds                                                   cloud-demo_orderservice_1

08ebd298af25   cloud-demo_gateway        "/bin/sh -c 'java -j…"   56 seconds ago   Up 46 seconds   0.0.0.0:10010->10010/tcp, :::10010->10010/tcp   cloud-demo_gateway_1

89535c870752   cloud-demo_userservice    "/bin/sh -c 'java -j…"   56 seconds ago   Up 46 seconds                                                   cloud-demo_userservice_1

使用docker-compose logs -f查看日志

这里日志报错了，报错如下：
1
com.alibaba.nacos.api.exception.NacosException: failed to req API:/nacos/v1/ns/instance after all servers([nacos:8848]) tried: java.net.ConnectException: Connection refused (Connection refused)
nacos连接失败，其原因是user-service在nacos之前启动了，而nacos启动太慢了，user-service注册失败，而且也没有重试机制（等nacos启动完成后，重试注册，就可以避免这个问题）。所以建议nacos单独先启动，其他服务后启动，这里的解决方案是重启另外三个服务
1
docker-compose restart gateway userservice orderserivce
此时再查看日志，就不会再报错了

然后浏览器访问ip:10010/user/1?authorization=admin，可以成功访问用user信息

Docker镜像服务

镜像仓库（Docker Registery）有公共的和私有的两种形式：

公共仓库：例如Docker官方的DockerHub，国内也有一些云服务商提供类似于DockerHub的公开服，比如网易云镜像服务、DaoCloud镜像服务、阿里云镜像服务等
私有仓库：用户可以在本地搭建私有Docker Registery。

搭建私有镜像仓库

搭建镜像仓库可以基于Docker官方提供的DockerRegistry来实现。官网地址：https://hub.docker.com/_/registry

配置Docker信任地址

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

# 打开要修改的文件
vi /etc/daemon.json
# 添加内容：
"insecure-registries":["http://192.168.186.128:8080"]
# 重加载
systemctl daemon-reload
# 重启docker
systemctl restart docker

此时daemon文件中内容

{
  "registry-mirrors": ["https://ps8tfle7.mirror.aliyuncs.com"],
  "insecure-registries":["http://192.168.186.128:8080"]
}

注意两个内容之间要使用逗号隔开

带图形化界面版本

使用DockerCompose部署带有图象界面的DockerRegistry，命令如下：

version: '3.0'
services:
  registry:
    image: registry
    volumes:
      - ./registry-data:/var/lib/registry
      
  ui:
    image: joxit/docker-registry-ui:static
    ports:
      - 8080:80
    environment:
      - REGISTRY_TITLE=WZY私有仓库
      - REGISTRY_URL=http://registry:5000
    depends_on:
      - registry

这里建议创建一个文件夹，然后创建一个docker-compose.yml，将内容写入。

[root@localhost tmp]# mkdir docker-registry-ui
[root@localhost tmp]# cd docker-registry-ui/
[root@localhost docker-registry-ui]# touch docker-compose.yml
[root@localhost docker-registry-ui]# ll
总用量 0
-rw-r--r--. 1 root root 0 8月   6 15:16 docker-compose.yml

然后使用docker-compose up -d命令进行部署

浏览器访问http://192.168.186.128:8080/，就能看到带图形化界面的镜像仓库

推送、拉取镜像

推送镜像到私有镜像服务必须先tag，步骤如下

重新tag本地镜像（其实就是重新命名），名称前缀为私有仓库的地址：192.168.186.128:8080/

1	docker tag nginx:latest 192.168.186.128:8080/nginx:1.0

此时使用docker images查看镜像可以发现镜像打包成功

1
2
3

REPOSITORY                   TAG       IMAGE ID       CREATED          SIZE
192.168.186.128:8080/nginx   1.0       605c77e624dd   19 months ago    141MB
nginx                        latest    605c77e624dd   19 months ago    141MB

推送镜像

1	docker push 192.168.186.128:8080/nginx:1.0

可以看到私有仓库中出现了nginx：

拉取镜像

拉取前把原本的镜像删除掉

1	docker pull 192.168.186.128:8080/nginx:1.0

参考Kyle博客的推荐，进一步理解Docker：

什么是Docker？看这一篇干货文章就够了