什么是Docker#

微服务虽然具备各种各样的优势，但服务的拆分通用给部署带来了很大的麻烦。

• 分布式系统中，依赖的组件非常多，不同组件之间部署时往往会产生一些冲突。
• 在数百上千台服务中重复部署，环境不一定一致，会遇到各种问题

Docker和虚拟机的区别#

Docker可以让一个应用在任何操作系统中非常方便的运行。而虚拟机也能在一个操作系统中，运行另外一个操作系统，保护系统中的任何应用。

• 虚拟机（virtual machine）是在操作系统中模拟硬件设备，然后运行另一个操作系统，比如在 Windows 系统里面运行 Ubuntu 系统，这样就可以运行任意的Ubuntu应用了。
• Docker仅仅是封装函数库，并没有模拟完整的操作系统

Docker和虚拟机的差异：

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

Docker架构#

镜像操作#

1
docker pull nginx  # 拉取镜像
2
docker images    # 查看拉取的镜像
3

4
# docker save -o [保存的目标文件名称] [镜像名称]
5
docker save -o nginx.tar nginx:latest  # 保存镜像
6
docker rmi nginx:latest          # 删除镜像
7
docker load -i nginx.tar        # 加载镜像

容器操作#

容器保护三个状态：

• 运行：进程正常运行
• 暂停：进程暂停，CPU不再运行，并不释放内存
• 停止：进程终止，回收进程占用的内存、CPU等资源

数据卷（容器数据管理）#

在之前的nginx案例中，修改nginx的html页面时，需要进入nginx内部。并且因为没有编辑器，修改文件也很麻烦。

这就是因为容器与数据（容器内文件）耦合带来的后果。

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

1
docker volume [COMMAND]

1
docker volume create html

1
docker volume ls

1
docker volume inspect html

1
docker run \\
2
  --name mn \\
3
  -v html:/root/html \\
4
  -p 8080:80
5
  nginx \\

1
# --privileged=true参数，让容器拥有真正的root权限
2
docker run --privileged=true --name mysql5.7 -p 3307:3306 \\
3
-e MYSQL_ROOT_PASSWORD=123456 -d \\
4
-v /mydata/mysql/data:/var/lib/mysql \\
5
-v /mydata/mysql/conf:/etc/mysql \\
6
-v /mydata/mysql/log:/var/log/mysql \\
7
mysql:5.7

镜像结构#

镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。

简单来说，镜像就是在系统函数库、运行环境基础上，添加应用程序文件、配置文件、依赖文件等组合，然后编写好启动脚本打包在一起形成的文件。

我们要构建镜像，其实就是实现上述打包的过程。

Dockerfile语法#

构建自定义的镜像时，并不需要一个个文件去拷贝，打包。

我们只需要告诉Docker，我们的镜像的组成，需要哪些BaseImage、需要拷贝什么文件、需要安装什么依赖、启动脚本是什么，将来Docker会帮助我们构建镜像。

而描述上述信息的文件就是Dockerfile文件。

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

构建Java项目#

基于java8构建Java项目

构建java项目的镜像，可以在已经准备了JDK的基础镜像基础上构建。

• 编写Dockerfile文件：

  • 基于java<8-alpine作为基础镜像>
  • 将app.jar拷贝到镜像中
  • 暴露端口
  • 编写入口ENTRYPOINT

  1
  FROM java:8-alpine
  2
  COPY ./app.jar /tmp/app.jar
  3
  EXPOSE 8090
  4
  ENTRYPOINT java -jar /tmp/app.jar

• 使用docker build命令构建镜像

• 使用docker run创建容器并运行

初识DockerCompose#

Compose文件是一个文本文件，通过指令定义集群中的每个容器如何运行。格式如下：

1
version: "3.8"
2
 services:
3
  mysql:
4
    image: mysql:5.7.25
5
    environment:
6
     MYSQL_ROOT_PASSWORD: 123
7
    volumes:
8
     - "/tmp/mysql/data:/var/lib/mysql"
9
     - "/tmp/mysql/conf/hmy.cnf:/etc/mysql/conf.d/hmy.cnf"
10
  web:
11
    build: .
12
    ports:
13
     - "8090:8090"

上面的Compose文件就描述一个项目，其中包含两个容器：

• mysql：一个基于mysql:5.7.25镜像构建的容器，并且挂载了两个目录
• web：一个基于docker build临时构建的镜像容器，映射端口时8090

其实DockerCompose文件可以看做是将多个docker run命令写到一个文件，只是语法稍有差异。

部署微服务集群#

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

实现思路：

1. 编写docker-compose文件

   1
   version: "3.2"
   2
   
   3
   services:
   4
     nacos:
   5
       image: nacos/nacos-server
   6
       environment:
   7
         MODE: standalone
   8
       ports:
   9
         - "8848:8848"
   10
     mysql:
   11
       image: mysql:5.7.25
   12
       environment:
   13
         MYSQL_ROOT_PASSWORD: 123
   14
       volumes:
   15
         - "$PWD/mysql/data:/var/lib/mysql"
   16
         - "$PWD/mysql/conf:/etc/mysql/conf.d/"
   17
     userservice:
   18
       build: ./user-service
   19
     orderservice:
   20
       build: ./order-service
   21
     gateway:
   22
       build: ./gateway
   23
       ports:
   24
         - "10010:10010"

   其中包含5个service服务：

   • nacos：作为注册中心和配置中心
     • image: nacos/nacos-server： 基于nacos/nacos-server镜像构建
     • environment：环境变量
       • MODE: standalone：单点模式启动
     • ports：端口映射，这里暴露了8848端口
   • mysql：数据库
     • image: mysql:5.7.25：镜像版本是mysql<5>.7.25
     • environment：环境变量
       • MYSQL_ROOT_PASSWORD: 123：设置数据库root账户的密码为123
     • volumes：数据卷挂载，这里挂载了mysql的data、conf目录，其中有我提前准备好的数据
   • userservice、orderservice、gateway：都是基于Dockerfile临时构建的

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

   因为微服务将来要部署为docker容器，而容器之间互联不是通过IP地址，而是通过容器名。这里我们将order-service、user-service、gateway服务的mysql、nacos地址都修改为基于容器名的访问。

   1
   spring:
   2
     datasource:
   3
       url: jdbc:mysql://mysql:3306/cloud_order?useSSL=false
   4
       username: root
   5
       password: 123
   6
       driver-class-name: com.mysql.jdbc.Driver
   7
     application:
   8
       name: orderservice
   9
     cloud:
   10
       nacos:
   11
         server-addr: nacos:8848 # nacos服务地址

3. 使用maven打包工具，将项目中的每个微服务都打包为app.jar

   接下来需要将我们的每个微服务都打包。因为之前查看到Dockerfile中的jar包名称都是app.jar，因此我们的每个微服务都需要用这个名称。

   可以通过修改pom.xml中的打包名称来实现，每个微服务都需要修改：

   1
   <build>
   2
     <!-- 服务打包的最终名称 -->
   3
     <finalName>app</finalName>
   4
     <plugins>
   5
       <plugin>
   6
         <groupId>org.springframework.boot</groupId>
   7
         <artifactId>spring-boot-maven-plugin</artifactId>
   8
       </plugin>
   9
     </plugins>
   10
   </build>

4. 将打包好的app.jar拷贝到cloud-demo中的每一个对应的子目录中

5. 将cloud-demo上传至虚拟机，利用 docker-compose up -d 来部署

推送拉取镜像#

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

• 重新tag本地镜像，名称前缀为私有仓库的地址：192.168.150.101<8080>/

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

• 推送镜像

1
docker push 192.168.150.101:8080/nginx:1.0

• 拉取镜像

1
docker pull 192.168.150.101:8080/nginx:1.0