容器虚拟化技术Docker（三）DockerFile、Docker部署微服务、Docker-compose容器编排、Docker监控

不熟悉的docker的可以参考：

容器虚拟化技术Docker（一）简介、安装、常见命令、数据卷、安装常规软件

容器虚拟化技术Docker（二）mysql主从配置案例、redis集群搭建及扩容、缩容案例详解

1、DockerFile

Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。

官网地址: https://docs.docker.com/engine/reference/builder/

构建步骤

• 编写Dockerfile文件

• docker build命令构建镜像

• docker run依镜像运行容器实例

(1)Dockerfile的构建过程

Dockerfile内容基础知识

1：每条保留字指令都必须为大写字母且后面要跟随至少一个参数
2：指令按照从上到下，顺序执行
3：#表示注释
4：每条指令都会创建一个新的镜像层并对镜像进行提交

Docker执行Dockerfile的大致流程

（1）docker从基础镜像运行一个容器
（2）执行一条指令并对容器作出修改
（3）执行类似docker commit的操作提交一个新的镜像层
（4）docker再基于刚提交的镜像运行一个新容器
（5）执行dockerfile中的下一条指令直到所有指令都执行完成

从应用软件的角度来看，Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段，

* Dockerfile是软件的原材料

* Docker镜像是软件的交付品

* Docker容器则可以认为是软件镜像的运行态，也即依照镜像运行的容器实例

Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

(2)Dockerfile常用的保留字指令

tomcat8的dockerfile地址: https://github.com/docker-library/tomcat

FROM

基础镜像，当前新镜像是基于哪个镜像的，指定一个已经存在的镜像作为模板，第一条必须是from

MAINTAINER

镜像维护者的姓名和邮箱地址

RUN

容器构建时需要运行的命令，两种格式

shell格式

exec格式

RUN是在 docker build时运行

EXPOSE

当前容器对外暴露出的端口

WORKDIR

指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点

USER

指定该镜像以什么样的用户去执行，如果都不指定，默认是root

ENV

用来在构建镜像过程中设置环境变量

ENV MY_PATH /usr/mytest

这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；也可以在其它指令中直接使用这些环境变量

比如：WORKDIR $MY_PATH

ADD

将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包

COPY

类似ADD，拷贝文件和目录到镜像中。 将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置

COPY src dest

<src源路径>：源文件或者源目录

<dest目标路径>：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。

VOLUME

容器数据卷，用于数据保存和持久化工作

CMD

指定容器启动后的要干的事情

Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换

和前面RUN命令的区别

CMD是在docker run 时运行。

RUN是在 docker build时运行。

ENTRYPOINT

也是用来指定一个容器启动时要运行的命令

类似于 CMD 指令，但是ENTRYPOINT不会被docker run后面的命令覆盖， 而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序。

ENTRYPOINT可以和CMD一起用，一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参。

当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD的内容作为参数传递给ENTRYPOINT指令，他两个组合会变成“”

FROM nginx

ENTRYPOINT ["nginx", "-c"]  # 定参
CMD ["/etc/nginx/nginx.conf"] # 变参

是否传参	按照dockerfile编写执行	传参运行
Docker命令	docker run nginx:test	docker run nginx:test -c /etc/nginx/new.conf
衍生出的实际命令	nginx -c /etc/nginx/nginx.conf	nginx -c /etc/nginx/new.conf

在执行docker run的时候可以指定 ENTRYPOINT 运行所需的参数。

如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。

(3) 案例: 自定义镜像mycentosjava8

要求： Centos7镜像具备vim+ifconfig+jdk8

1、准备编写Dockerfile文件

FROM centos
MAINTAINER yyds<yyds@126.com>
 
ENV MYPATH /usr/local
WORKDIR $MYPATH
 
#安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
#ADD 是相对路径jar,把jdk-8u171-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
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
 
EXPOSE 80
 
CMD echo $MYPATH
CMD echo "success--------------ok"
CMD /bin/bash

2、构建

docker build -t 新镜像名字:TAG .

docker build -t centosjava8:1.5 .

注意，上面TAG后面有个空格，有个点

3、运行

docker run -it 新镜像名字:TAG

docker run -it centosjava8:1.5 /bin/bash

2、Docker部署微服务

(1) 通过IDEA新建一个普通微服务模块

pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.yyds</groupId>
    <artifactId>docker_boot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>docker_boot</name>


    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <junit.version>4.12</junit.version>
        <log4j.version>1.2.17</log4j.version>
        <lombok.version>1.16.18</lombok.version>
        <mysql.version>5.1.47</mysql.version>
        <druid.version>1.1.16</druid.version>
        <mapper.version>4.1.5</mapper.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>


    <dependencies>
        <!--SpringBoot通用依赖模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.5.6</version>
            <scope>compile</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
        </plugins>
    </build>



</project>

配置文件

server.port=6001

启动类

package com.yyds.docker_boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DockerBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(DockerBootApplication.class, args);
        System.out.println("*******************DockerBootApplication启动成功*****************************");
    }
}

业务类

package com.yyds.docker_boot.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;


@RestController
public class OrderController {


    @Value("${server.port}")
    private String port;

    @RequestMapping("/order/docker")
    public String helloDocker(){
        return "hello docker"+"\t"+port+"\t"+ UUID.randomUUID().toString();
    }


    @RequestMapping(value ="/order/index",method = RequestMethod.GET)
    public String index(){
        return "服务端口号: "+"\t"+port+"\t"+UUID.randomUUID().toString();
    }

}

IDEA工具里面搞定微服务jar包

(2) 通过dockerfile发布微服务部署到docker容器

编写Dockerfile

# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER yyds
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为zzyy_docker.jar
ADD docker_boot-0.0.1-SNAPSHOT.jar yyds_docker.jar
# 运行jar包
RUN bash -c 'touch /yyds_docker.jar'
ENTRYPOINT ["java","-jar","/yyds_docker.jar"]
#暴露6001端口作为微服务
EXPOSE 6001

将微服务jar包和Dockerfile文件上传到同一个目录下/mydocker

[root@centos04 mydocker]# pwd
/mydocker
[root@centos04 mydocker]# ll
total 19064
-rw-r--r--. 1 root root 19514875 Jan 21 10:56 docker_boot-0.0.1-SNAPSHOT.jar
-rw-r--r--. 1 root root      454 Jan 21 11:07 Dockerfile

构建镜像

docker build -t yyds_docker:1.6 .

# 注意最后有个点

运行容器

docker run -d -p 6001:6001 yyds_docker:1.6

[root@centos04 mydocker]# docker ps
CONTAINER ID   IMAGE             COMMAND                  CREATED         STATUS         PORTS                                       NAMES
08b0a0fab5c3   yyds_docker:1.6   "java -jar /yyds_doc…"   7 seconds ago   Up 6 seconds   0.0.0.0:6001->6001/tcp, :::6001->6001/tcp   elastic_elgamal

访问测试

http://centos04:6001/order/index

3、Docker网络

(1) 常用基本命令

[root@centos04 mydocker]# docker network --help

Usage:  docker network COMMAND

Manage networks

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
  
  

# 查看网络
docker network ls
# 查看网络源数据
docker network inspect  XXX网络名字
# 删除网络
docker network rm XXX网络名字

默认创建3大网络模式

[root@centos04 mydocker]# docker network ls
NETWORK ID     NAME      DRIVER    SCOPE
ff7c9b413b39   bridge    bridge    local
e17fc074f9be   host      host      local
a914934c21b7   none      null      local

(2) 网络模式

· 容器间的互联和通信以及端口映射

· 容器IP变动时候可以通过服务名直接网络通信而不受到影响

bridge模式：使用--network  bridge指定，默认使用docker0
host模式：使用--network host指定
none模式：使用--network none指定
container模式：使用--network container:NAME或者容器ID指定

1、bridge模式

• Docker使用Linux桥接，在宿主机虚拟一个Docker容器网桥(docker0)，Docker启动一个容器时会根据Docker网桥的网段分配给容器一个IP地址，称为Container-IP，同时Docker网桥是每个容器的默认网关。因为在同一宿主机内的容器都接入同一个网桥，这样容器之间就能够通过容器的Container-IP直接通信。

• docker run 的时候，没有指定network的话默认使用的网桥模式就是bridge，使用的就是docker0。在宿主机ifconfig,就可以看到docker0和自己create的network eth0，eth1，eth2……代表网卡一，网卡二，网卡三……，lo代表127.0.0.1，即localhost，inet addr用来表示网卡的IP地址

• 网桥docker0创建一对对等虚拟设备接口一个叫veth，另一个叫eth0，成对匹配。

整个宿主机的网桥模式都是docker0，类似一个交换机有一堆接口，每个接口叫veth，在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫veth pair）；

每个容器实例内部也有一块网卡，每个接口叫eth0；

docker0上面的每个veth匹配某个容器实例内部的eth0，两两配对，一一匹配。

通过上述，将宿主机上的所有容器都连接到这个内部网络上，两个容器在同一个网络下,会从这个网关下各自拿到分配的ip，此时两个容器的网络是互通的。

2、host模式

直接使用宿主机的 IP 地址与外界进行通信，不再需要额外进行NAT 转换。

容器将不会获得一个独立的Network Namespace， 而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。

3、none模式

在none模式下，并不为Docker容器进行任何网络配置。 也就是说，这个Docker容器没有网卡、IP、路由等信息，只有一个lo

需要我们自己为Docker容器添加网卡、配置IP等。

4、container⽹络模式

新建的容器和已经存在的一个容器共享一个网络ip配置而不是和宿主机共享。新创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围等。同样，两个容器除了网络方面，其他的如文件系统、进程列表等还是隔离的。

(3) 使用网络模式实现服务名直接网络通信

docker容器内部的ip是有可能会发生改变的，因此需要使用服务名进行通信。

docker run -d -p 8081:8080   --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080   --name tomcat82 billygoo/tomcat8-jdk8

# 使用ip进行ping可以ping通
root@30a14a65bdbf:/usr/local/tomcat# ping 172.17.0.3
PING 172.17.0.3 (172.17.0.3) 56(84) bytes of data.
64 bytes from 172.17.0.3: icmp_seq=1 ttl=64 time=0.055 ms
64 bytes from 172.17.0.3: icmp_seq=2 ttl=64 time=0.100 ms
64 bytes from 172.17.0.3: icmp_seq=3 ttl=64 time=0.043 ms
64 bytes from 172.17.0.3: icmp_seq=4 ttl=64 time=0.083 ms
^C
--- 172.17.0.3 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3002ms
rtt min/avg/max/mdev = 0.043/0.070/0.100/0.023 ms

# 使用名字ping不通
root@30a14a65bdbf:/usr/local/tomcat# ping tomcat82
ping: tomcat82: No address associated with hostname
root@30a14a65bdbf:/usr/local/tomcat# 

自定义桥接网络,自定义网络默认使用的是桥接网络bridge

[root@centos04 ~]# docker network create yyds_network
2b6fa507ed11d3055d380d93e34415b0e97653e1c37815a4736aa9a1b921bfb7
[root@centos04 ~]# docker network ls
NETWORK ID     NAME           DRIVER    SCOPE
ff7c9b413b39   bridge         bridge    local
e17fc074f9be   host           host      local
a914934c21b7   none           null      local
2b6fa507ed11   yyds_network   bridge    local

# 新建容器加入上一步新建的自定义网络
docker run -d -p 8081:8080 --network yyds_network --name tomcat81 billygoo/tomcat8-jdk8
docker run -d -p 8082:8080 --network yyds_network --name tomcat82 billygoo/tomcat8-jdk8


# 此时可以ping通
[root@centos04 mydocker]# docker exec -it 5185a0376fab bash
root@5185a0376fab:/usr/local/tomcat# ping tomcat82
PING tomcat82 (172.18.0.3) 56(84) bytes of data.
64 bytes from tomcat82.yyds_network (172.18.0.3): icmp_seq=1 ttl=64 time=0.048 ms
64 bytes from tomcat82.yyds_network (172.18.0.3): icmp_seq=2 ttl=64 time=0.044 ms
64 bytes from tomcat82.yyds_network (172.18.0.3): icmp_seq=3 ttl=64 time=0.059 ms

# 结论：自定义网络本身就维护好了主机名和ip的对应关系（ip和域名都能通）

4、Docker-compose容器编排

Docker-Compose是Docker官方的开源项目， 负责实现对Docker容器集群的快速编排。你需要定义一个 YAML 格式的配置文件docker-compose.yml，写好多个容器之间的调用关系。然后，只要一个命令，就能同时启动/关闭这些容器。

官网: https://docs.docker.com/compose/compose-file/compose-file-v3/

下载官网: https://docs.docker.com/compose/install/

(1) Docker-compose安装

# 连接进行下载
curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

# 赋予权限
chmod +x /usr/local/bin/docker-compose

# 查看版本
docker-compose --version

(2) Compose的常用命令

docker-compose步骤

• 编写Dockerfile定义各个微服务应用并构建出对应的镜像文件

• 使用 docker-compose.yml 定义一个完整业务单元，安排好整体应用中的各个容器服务。

• 最后，执行docker-compose up命令 来启动并运行整个应用程序，完成一键部署上线

常用命令

Compose常用命令
docker-compose -h                           # 查看帮助
docker-compose up                           # 启动所有docker-compose服务
docker-compose up -d                        # 启动所有docker-compose服务并后台运行
docker-compose down                         # 停止并删除容器、网络、卷、镜像。
docker-compose exec  yml里面的服务id         # 进入容器实例内部  docker-compose exec docker-compose.yml文件中写的服务id /bin/bash
docker-compose ps                      # 展示当前docker-compose编排过的运行的所有容器
docker-compose top                     # 展示当前docker-compose编排过的容器进程
 
docker-compose logs  yml里面的服务id     # 查看容器输出日志
docker-compose config     # 检查配置
docker-compose config -q  # 检查配置，有问题才有输出
docker-compose restart   # 重启服务
docker-compose start     # 启动服务
docker-compose stop      # 停止服务

(3) 使用Compose编排微服务

1、使用idea创建微服务工程

创建一个包含访问Mysql，redis的工程，过程略。。。

2、使用Docker Compose进行编排

编写docker-compose.yml文件

version: "3"
 
services:
  microService:
    image: yyds_docker:1.6
    container_name: ms01
    ports:
      - "6001:6001"
    volumes:
      - /app/microService:/data
    networks: 
      - yyds_net 
    depends_on: 
      - redis
      - mysql
 
  redis:
    image: redis:6.0.8
    ports:
      - "6379:6379"
    volumes:
      - /app/redis/redis.conf:/etc/redis/redis.conf
      - /app/redis/data:/data
    networks: 
      - yyds_net
    command: redis-server /etc/redis/redis.conf
 
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: '123456'
      MYSQL_ALLOW_EMPTY_PASSWORD: 'no'
      MYSQL_DATABASE: 'hello'
      MYSQL_USER: 'yyds'
      MYSQL_PASSWORD: '123456'
    ports:
       - "3306:3306"
    volumes:
       - /app/mysql/db:/var/lib/mysql
       - /app/mysql/conf/my.cnf:/etc/my.cnf
       - /app/mysql/init:/docker-entrypoint-initdb.d
    networks:
      - yyds_net
    command: --default-authentication-plugin=mysql_native_password #解决外部无法访问
 
networks: 
   yyds_net:

修改yml文件，通过服务名访问，IP无关

server.port=6001

# ========================alibaba.druid相关配置=====================
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#spring.datasource.url=jdbc:mysql://192.168.42.104:3306/hello?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.url=jdbc:mysql://mysql:3306/hello?useUnicode=true&characterEncoding=utf-8&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.druid.test-while-idle=false

# ========================redis相关配置=====================
spring.redis.database=0
#spring.redis.host=192.168.42.104
spring.redis.host=redis
spring.redis.port=6379
spring.redis.password=
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=0

# ========================mybatis相关配置===================
mybatis.mapper-locations=classpath:mapper/*.xml
mybatis.type-aliases-package=com.yyds.docker.entities

# ========================swagger=====================
spring.swagger2.enabled=true

编写Dockerfile

# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER yyds
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为yyds_docker.jar
ADD docker_boot-0.0.1-SNAPSHOT.jar yyds_docker.jar
# 运行jar包
RUN bash -c 'touch /yyds_docker.jar'
ENTRYPOINT ["java","-jar","/yyds_docker.jar"]
#暴露6001端口作为微服务
EXPOSE 6001

构建镜像

docker build -t yyds_docker:1.6 .

执行 docker-compose up 或者 执行 docker-compose up -d

5、Docker轻量级可视化工具Portainer

Portainer 是一款轻量级的应用，它提供了图形化界面，用于方便地管理Docker环境，包括单机环境和集群环境。

官网

https://www.portainer.io/

https://docs.portainer.io/v/ce-2.9/start/install/server/docker/linux

# docker命令安装

docker run -d -p 8000:8000 -p 9000:9000 --name portainer --restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
-v portainer_data:/data \
portainer/portainer

第一次登录需创建admin，访问地址：xxx.xxx.xxx.xxx:9000

用户名：默认admin

密码8位，随便你写

具体操作，可以参考：Docker 轻量级可视化工具Portainer

6、Docker容器监控之 CAdvisor+InfluxDB+Granfana

原生命令:docker stats

通过docker stats命令可以很方便的看到当前宿主机上所有容器的CPU,内存以及网络流量等数据，但是，docker stats统计结果只能是当前宿主机的全部容器，数据资料是实时的，没有地方存储、没有健康指标过线预警等功能。

CAdvisor监控收集+InfluxDB存储数据+Granfana展示图表

具体可参考：Docker容器监控之 CAdvisor+InfluxDB+Granfana