Docker-Compose（二）Docker-Compose部署SpringBoot+Redis+MySQL+Nginx

ゞ浴缸里的玫瑰 2022-11-21 11:44 730阅读 0赞

## 1、前提 ##

springboot 整合redis、mysql

nginx负载均衡

## 2、Docker Compose安装 ##

[Docker-Compose（一）Docker-Compose安装][Docker-Compose_Docker-Compose]

## 3、项目搭建 ##

springboot 整合 mysql、redis服务

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center]

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.yi</groupId>
        <artifactId>springboot-docker</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>springboot-docker</name>
        <packaging>jar</packaging>
        <description></description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.4.RELEASE</version>
            <relativePath/> 
        </parent>
    
        <properties>
            <java.version>1.8</java.version>
            <commons-pool2.version>2.6.1</commons-pool2.version>
        </properties>
    
        <dependencies>
            <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-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-pool2</artifactId>
                <version>${commons-pool2.version}</version>
            </dependency>
    
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
    
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

package com.yi.config;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.boot.autoconfigure.AutoConfigureAfter;
    import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.cache.RedisCacheManager;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import java.time.Duration;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @method redis配置： RedisConfig文件名不能修改 ; 配置序列化方式以及缓存管理器 @EnableCaching 开启缓存
     * @author Mr yi
     */
    @Configuration
    @EnableCaching
    @AutoConfigureAfter(RedisAutoConfiguration.class)
    public class RedisConfig {
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(connectionFactory);
            template.setValueSerializer(jackson2JsonRedisSerializer());
            // 使用StringRedisSerializer来序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
            template.setHashKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(jackson2JsonRedisSerializer());
            template.afterPropertiesSet();
            return template;
        }
    
        @Bean
        public RedisSerializer<Object> jackson2JsonRedisSerializer() {
            // 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
            Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
            ObjectMapper mapper = new ObjectMapper();
            mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            serializer.setObjectMapper(mapper);
            return serializer;
        }
    
        @Bean
        public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
            // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
            // 设置缓存的默认过期时间，也是使用Duration设置 （此处为缓存1分钟）
            config = config.entryTtl(Duration.ofMinutes(1))
                    // 设置 key为string序列化
                    .serializeKeysWith(
                            RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                    // 设置value为json序列化
                    .serializeValuesWith(
                            RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()))
                    // 不缓存空值
                    .disableCachingNullValues();
    
            // 设置一个初始化的缓存空间set集合
            Set<String> cacheNames = new HashSet<>();
            cacheNames.add("timeGroup");
            cacheNames.add("user");
            cacheNames.add("UUser");
    
            // 对每个缓存空间应用不同的配置
            Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
            configMap.put("timeGroup", config);
            // 该缓存空间，缓存时间120秒
            configMap.put("user", config.entryTtl(Duration.ofSeconds(120)));
            configMap.put("UUser", config.entryTtl(Duration.ofDays(3)));
    
            // 使用自定义的缓存配置初始化一个cacheManager
            RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory)
                    // 一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
                    .initialCacheNames(cacheNames).withInitialCacheConfigurations(configMap).build();
            return cacheManager;
        }
    
    }

server:
      port: 8080
      #servlet:
        #context-path: /springboot-docker
    
    spring:
      application:
        name: springboot-docker
      datasource:
          host: 127.0.0.1
          #url: jdbc:mysql://127.0.0.1:3306/test?serverTimezone=GMT%2B8
          url: jdbc:mysql://${spring.datasource.host}:3306/test?serverTimezone=GMT%2B8
          username: root
          password: 123456
          driver-class-name: com.mysql.jdbc.Driver
          max-idle: 10
          max-wait: 1000
          min-idle: 5
          initial-size: 5
      #单个redis配置
      redis:
        #Redis服务器地址
        host: 127.0.0.1
        #Redis服务器连接端口
        port: 6379
        #Redis服务器连接密码（默认为空）
        password: 123456
        # Redis数据库索引（默认为0）
        database: 0
        lettuce:
          pool:
            # 连接池最大连接数（使用负值表示没有限制） 默认 8
            max-active: 32
            # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
            max-wait: -1
            # 连接池中的最大空闲连接 默认 8
            max-idle: 8
            # 连接池中的最小空闲连接 默认 0
            min-idle: 0
            # 连接超时时间（毫秒）
            timeout: 0

> host 配置为 127.0.0.1 本地即可， docker-compose 服务编排时会主动处理

package com.yi;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.List;
    import java.util.Map;
    import java.util.logging.Logger;
    
    @SpringBootApplication
    @RestController
    public class SpringbootApplication {
    
        @Autowired
        private RedisTemplate redisTemplate;
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        public static void main(String[] args) {
            SpringApplication.run(SpringbootApplication.class, args);
        }
    
        @RequestMapping("/hello")
        public String hello() {
            return "hello world!";
        }
    
        @RequestMapping("/getReids")
        public String getReids() {
            String sql = "select * from user";
            List<Map<String, Object>> list =  jdbcTemplate.queryForList(sql);
            redisTemplate.opsForValue().set("data1", list);
            Object uu = redisTemplate.opsForValue().get("data1");
    
            return uu.toString();
        }
    
        @RequestMapping("/saveReids")
        public String saveReids(@RequestParam(value = "name", defaultValue = "yi") String name) {
            String sql = "insert into user (name) values(?)";
            jdbcTemplate.update(sql, new Object[]{name});
            return name.toString();
        }
    
        @RequestMapping("/deleteReids")
        public String deleteReids() {
            redisTemplate.delete("data1");
            return "delete success!";
        }
    
    
    }

**本地测试**

启动redis

redis-server redis.windows.conf

输入地址访问，检查服务是否正常

http://127.0.0.1:8080/hello
    http://127.0.0.1:8080/getReids

![在这里插入图片描述][20201103204022150.png_pic_center]

## 4、docker配置文件 ##

创建docker-bulid 目录，目录结构如图所示

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 1]

**4.1、Dockerfile**

构建springboot-docker镜像。它包含安装服务运行所需的环境、程序代码等

# Docker image for springboot file run
    # VERSION 0.0.1
    # Author: yi
    # 基础镜像使用java
    FROM java:8
    # 作者
    MAINTAINER yi <yi@gmail.com>
    # VOLUME 指定了临时文件目录为/tmp。
    # 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp
    VOLUME /tmp
    # 将jar包添加到容器中并更名为app.jar
    ADD springboot-docker-0.0.1-SNAPSHOT.jar app.jar
    # 运行jar包
    #RUN bash -c 'touch /app.jar'
    #执行项目 app.jar。为了缩短 Tomcat 启动时间，添加一个系统属性指向 “/dev/./urandom” 作为 Entropy Source
    ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

**4.2、docker-compose**

version: "3"
    
    services:
    
      service_redis:
        image: redis:4.0.14
        container_name: container_redis
        environment:
          - TZ=Asia/Shanghai
        volumes:
          - ./config/redis/redis.conf:/usr/local/etc/redis/redis.conf
          - ./data/redis/:/data/
          - ./log/redis/:/var/log/redis/
        command: redis-server /usr/local/etc/redis/redis.conf
        ports:
          - "6379:6379"
        restart: always
       # networks:
        #  - appnet
    
      service_mysql:
        image: mysql:5.7
        container_name: container_mysql
        environment:
          TZ: Asia/Shanghai
          MYSQL_ROOT_PASSWORD: 123456
          MYSQL_ROOT_HOST: '%'
        volumes:
          - ./config/mysql/my.cnf:/etc/mysql/conf.d/my.cnf
          - ./data/mysql/:/var/lib/mysql/
          - ./data/init/:/docker-entrypoint-initdb.d/
          - ./log/mysql/:/var/log/mysql/
        command: [
          '--character-set-server=utf8mb4',
          '--collation-server=utf8mb4_unicode_ci'
        ]
        ports:
          - "3306:3306"
        restart: always
        #networks:
        #  - appnet
    
      service_web:
        build:
          context: .
          dockerfile: Dockerfile
        environment:
          TZ: Asia/Shanghai
          spring.datasource.host: service_mysql
          spring.redis.host: service_redis
        expose:
          - "8080"
        depends_on:
          - service_redis
          - service_mysql
        restart: always
        #networks:
         # - appnet
    
      service_nginx:
        container_name: container_nginx
        image: nginx:1.8
        environment:
          - TZ=Asia/Shanghai
        ports:
          - "8000:8000"
        volumes:
          - ./config/nginx/nginx.conf:/etc/nginx/nginx.conf
          - ./data/nginx/:/usr/share/nginx/html/
          - ./log/nginx/:/var/log/nginx/
        depends_on:
          - service_web
        restart: always
    
    #networks:
      #appnet:
        #driver: bridge

> docker-compose 中包含4项服务，其中service\_redis、service\_mysql、service\_nginx 是需要下载的镜像（如果本地没有），service\_web 是需要构建的镜像，使用Dockerfile进行镜像构建。

> version: ‘3’ : 构建文件的语法版本信息。表示使用第三代语法

**4.3、Redis 服务：**

*  **service\_redis**：服务名称，可自定义。
 *  **image**：指定镜像来启动容器，如果本地不存在，从docker hub下载。
 *  **container\_name**：容器名称，可自定义。默认自动生成，生成规则格式：  
    【docker-compose.yml 文件的父目录名称 + \_ + 服务名称 + 从一开始的数字】。
 *  **environment**：为启动的容器添加环境变量。此处配置了容器的时区。
 *  **volumes**：【 宿主机：容器】，映射本地目录下的配置文件到容器指定地址下。这里映射了配置文件，数据目录以及日志目录。
 *  **command**：容器启动后执行的命令。此处命令为 使用配置文件来启动 Redis 容器。
 *  **ports**：端口映射，宿主机端口:容器端口。
 *  **restart**：always时，表示如果容器启动失败，会一直尝试重连。
 *  **networks**：加入指定网络

**4.4、MySQL 服务：**

*  **service\_redis**：服务名称，可自定义。
 *  **image**：指定镜像来启动容器，如果本地不存在，从docker hub下载。
 *  **container\_name**：容器名称，可自定义。默认自动生成，生成规则格式：  
    【docker-compose.yml 文件的父目录名称 + \_ + 服务名称 + 从一开始的数字】。
 *  **environment**：为启动的容器添加环境变量。这里配置了容器的时区，以及数据库 ROOT 密码和权限。
 *  **volumes**：【 宿主机：容器】，映射本地目录下的配置文件到容器指定地址下。这里映射了配置文件，数据目录，初始化 SQL 目录以及日志目录。
 *  **command**：容器启动后执行的命令。此处命令为设置字符编码。
 *  **ports**：端口映射，宿主机端口:容器端口。
 *  **restart**：always时，表示如果容器启动失败，会一直尝试重连。
 *  **networks**：加入指定网络

**4.5、Nginx服务：**

*  **service\_redis**：服务名称，可自定义。
 *  **image**：指定镜像来启动容器，如果本地不存在，从docker hub下载。
 *  **container\_name**：容器名称，可自定义。默认自动生成，生成规则格式：  
    【docker-compose.yml 文件的父目录名称 + \_ + 服务名称 + 从一开始的数字】。
 *  **environment**：为启动的容器添加环境变量。这里配置了容器的时区。
 *  **volumes**：【 宿主机：容器】，映射本地目录下的配置文件到容器指定地址下。这里映射了配置文件，数据目录以及日志目录。
 *  **ports**：端口映射，宿主机端口:容器端口。
 *  **depends\_on** ：依赖与指定的服务。容器启动时，会先启动依赖服务，再启动当前服务。
 *  **restart**：always时，表示如果容器启动失败，会一直尝试重连。
 *  **networks**：加入指定网络

**4.6、Springboot Web服务：**

*  **service\_redis**：服务名称，可自定义。
 *  **build**：指定 Dockerfile 文件位置，构建镜像，并使用这个镜像来启动容器。
 *  **environment**：为启动的容器添加环境变量。指定了 MySQL 的 host 为 service\_mysql 服务，Redis 的 host 为 service\_redis 服务。
 *  **ports**：端口映射，宿主机端口:容器端口。
 *  **depends\_on**：always时，表示如果容器启动失败，会一直尝试重连。
 *  **expose** ：暴露容器内端口，不映射到宿主机。因为 SpringBoot 服务会被 Nginx 做代理转发，所以不用暴露并映射到外部。
 *  **networks**：加入指定网络

**4.7、bulid config目录**

**my.cnf**

> \#开启 bin-log，并指定文件目录和文件名前缀  
> log-bin=/var/log/mysql/binlog

需要配置了 bin-log 文件目录，则 volumes 中映射的 `- ./log/mysql/:/var/log/mysql/`目录才会有数据

[client]
    
    default-character-set=utf8mb4
    
    
    [mysqld]
    
    character-set-client-handshake = FALSE
    
    character-set-server = utf8mb4
    
    collation-server = utf8mb4_unicode_ci
    
    # 数据库唯一 ID，主从的标识号绝对不能重复。
    server-id = 1
    
    # 开启 bin-log，并指定文件目录和文件名前缀
    log-bin=/var/log/mysql/binlog
    
    # bin-log 日志文件格式，设置为 MIXED 可以防止主键重复。
    binlog_format = mixed
    
    [mysql]
    default-character-set=utf8mb4

**nginx.conf**

upstream webhost{
            server docker-compose_service_springboot_1:8080 weight=1;
            server docker-compose_service_springboot_2:8080 weight=2;
        }

① 访问 Nginx 服务会转发到 SpringBoot 服务。

② SpringBoot 容器名称是自动生成的，生成规则为 【docker-compose.yaml 文件的父目录名称 + \_ + 服务名称 + 从一开始的数字】。

③ SpringBoot 容器端口都是 8080。

④ 访问比例为 1:2。

#user  nobody;
    worker_processes  1;
    
    events {
        worker_connections  1024;
    }
    
    http {
        include       mime.types;
        default_type  application/octet-stream;
        sendfile        on;
        keepalive_timeout  65;
    
        upstream webhost{
            server docker-compose_service_springboot_1:8080 weight=1;
            server docker-compose_service_springboot_2:8080 weight=2;
        }
    
        server {
            listen       8000;
            server_name  localhost;
    
            location / {
                proxy_pass   http://webhost;
            }
    
    		location /index {
    			root /usr/share/nginx/html;
                index  index.html index.htm;
            }
    
            error_page   500 502 503 504  /50x.html;
            location = /50x.html {
                root   html;
            }
    
        }
    
    }

**redis.conf**

> daemonize no：设置前台启动，在 Docker 中后台启动 Redis 容器会报错  
> requirepass 123456，设置redis密码  
> \#bind 127.0.0.1：注释，允许外网访问

# Redis configuration file example.
    protected-mode yes
    
    port 6379
    
    tcp-backlog 511
    
    timeout 0
    
    tcp-keepalive 300
    
    daemonize no
    
    supervised no
    
    pidfile /var/run/redis_6379.pid
    
    loglevel notice
    
    logfile "/var/log/redis/redis.log"
    
    databases 16
    
    always-show-logo yes
    
    save 900 1
    save 300 10
    save 60 10000
    
    stop-writes-on-bgsave-error yes
    
    rdbcompression yes
    
    rdbchecksum yes
    
    dbfilename dump.rdb
    
    dir ./
    
    slave-serve-stale-data yes
    
    slave-read-only yes
    
    repl-diskless-sync no
    
    repl-diskless-sync-delay 5
    
    repl-disable-tcp-nodelay no
    
    slave-priority 100
    
    # requirepass foobared
    requirepass 123456
    
    lazyfree-lazy-eviction no
    lazyfree-lazy-expire no
    lazyfree-lazy-server-del no
    slave-lazy-flush no
    
    appendonly no
    
    appendfilename "appendonly.aof"
    
    appendfsync everysec
    
    no-appendfsync-on-rewrite no
    
    auto-aof-rewrite-percentage 100
    auto-aof-rewrite-min-size 64mb
    
    aof-load-truncated yes
    
    aof-use-rdb-preamble no
    
    lua-time-limit 5000
    
    slowlog-log-slower-than 10000
    
    slowlog-max-len 128
    
    latency-monitor-threshold 0
    
    notify-keyspace-events ""
    
    hash-max-ziplist-entries 512
    hash-max-ziplist-value 64
    
    list-max-ziplist-size -2
    
    list-compress-depth 0
    
    set-max-intset-entries 512
    
    zset-max-ziplist-entries 128
    zset-max-ziplist-value 64
    
    hll-sparse-max-bytes 3000
    
    activerehashing yes
    
    client-output-buffer-limit normal 0 0 0
    client-output-buffer-limit slave 256mb 64mb 60
    client-output-buffer-limit pubsub 32mb 8mb 60
    
    hz 10
    
    aof-rewrite-incremental-fsync yes

## 5、docker部署 ##

前提条件，已安装docker、Docker-Compose，具体参考其它章节

**5.1、指定拷贝build目录到远程服务器上**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 2]

日志目录赋值权限：

chmod -R 777 log/

**5.2、启动 Docker服务**

systemctl start docker.service

**5.3、启动服务**

> docker-compose 命令可以自动完成包括构建镜像，(重新)创建服务，启动服务，并关联服务相关容器的一系列操作。  
> docker-compose up：最基本的启动命令  
> \-d：后台启动  
> –scale：扩展服务节点，格式为 服务名=个数

docker-compose up -d --scale service_web=2

![在这里插入图片描述][20201104091521540.png_pic_center]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 3]

**5.4、显示所有容器**

docker-compose ps

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 4]

**5.5、查看镜像构建情况**

docker-compose images

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 5]

**5.6、访问接口测试服务是否正常**

> ip:8000/hello

http://192.168.73.131:8000/hello
    http://192.168.73.131:8000/getReids

**5.7、停止并删除**

docker-compose down

docker-compose ps  
docker-compose images

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 6]

--------------------

git源码地址：[https://github.com/yilei111/docker][https_github.com_yilei111_docker]

[Docker-Compose_Docker-Compose]: https://yilei.blog.csdn.net/article/details/109511669
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/67a881704166497b8d459acd2fdbfd48.png
[20201103204022150.png_pic_center]: /images/20221120/6bfa8a6b82f44378bc18031499672605.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/2020110323333953.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201103231657717.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3,size_16,color_FFFFFF,t_70#pic_center
[20201104091521540.png_pic_center]: https://img-blog.csdnimg.cn/20201104091521540.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201103233613762.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201104090609677.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201103233757213.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201104091417217.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5OTE0ODM3,size_16,color_FFFFFF,t_70#pic_center
[https_github.com_yilei111_docker]: https://github.com/yilei111/docker