Docker学习5 - network容器网络、compose容器编排、简单Demo演示Redis、MySQL、SpringBoot项目编排部署

容器网络-network

概念

背景： docker容器内部的IP是有可能变动
 
作用： 1. 容器间的互联、通信记忆端口映射、2. 容器IP变动时可以通过服务名直接网络通信而不受影响
 
默认的docker0网卡网桥： 将所有容器和本地主机都放到同一个物理网络，Docker默认指定了docker0接口的IP地址和子网掩码，让主机和容器之间可以通过桥相互通信

 
docker进程启动后，系统会多出一个叫docker0的网卡信息

网络模式

默认--network bridge

--network host

很少用到--network none

--network container:NAME

Docker网络模式

bridge：桥接模式-为没给个容器分配、设置IP等，并将容器连接到一个docker0虚拟网桥

host：容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口

none：容器有独立的 Network namespace,但并没有对其进行任何网络设置，如分配veth pair和网桥连接，IP等

container：新创建的容器不会创建自己的网卡和配置自己的IP,而是和一个指定的容器共享IP、端口范围等

自定义网络

bridge-docker0网桥 - 使用虚拟的IP、端口

默认网络模式下：容器内的网关其实就是docker0

概念

1. 整个宿主机的网桥模式都是docker0,类似一个交换机有一堆接口，每个接口叫veth,在本地主机和容器内分别创建一个虚拟接口，并让他们彼此联通（这样一对接口叫veth pair)
    
2. 每个容器实例内部也有一块网卡，每个接口叫etho
    
3. docker0上面的每个veth匹配某个容器实例内部的eth0,两两配对，一一匹配。通过上述，将宿主机上的所有容器都连接到这个内部网络上，两个容器在同一个网络下，会从这个网关下各自拿到分配的ip,此时两个容器的网络是互通的

 

案例讲解

# 两个实例出来的容器容器方式
# 这样启动默认的网络就是使用 docker0的桥接模式
docker run -d -p 80:8080 --name=my-spring-boot my-spring-boot:1.0

docker run -d -p 81:8080 --name=my-spring-boot2 my-spring-boot:1.0

host - 使用物理机的IP、端口

概念

概念： 容器将不会获得一个独立的Network Namespace,而是和宿主机共用一个Network Namespace。容器将不会虚拟出自己的网卡而是使用宿主机的IP和端口。
 
简单理解： 相当于你把项目部署在宿主机上，你怎么访问宿主机的项目你就怎么访问–net=host的部署的容器项目，可能会出现部署失败，由于宿主机可能有其他项目占用宿主机的端口

案例

#会报警告说  使用 --net=host模式   -p端口映射不会起任何作用
docker run -d -p 8081:8080 --net=host --name=my-spring-boot3 my-spring-boot:1.0

# 改成这样就不会发出警告
docker run -d  --net=host --name=my-spring-boot3 my-spring-boot:1.0

none - 很少用

概念

禁用网络功能，只有lo标识（就是127.0.0.1表示本地回环）
 
详细： 此模式下，并不为Docker容器进行任何网络配置。这个Docker容器没有网卡、IP、路由等信息，只有一个lo链路回环，需要我们自己为此Docker容器添加网卡、配置IP等信息

案例

container - 利用其他运行中容器的虚拟网卡信息

概念

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

案例

自定义网络 - 用于划分某几个容器共处一个网络方便管理

桥接模式

注意1： 使用默认的桥接模式，使用：ping 容器名 === 不能互相ping通、使用：ping 容器IP === 能互相ping通
 
注意2： 指定同一个自定义桥接类型的网络容器内使用：ping 容器名 === 能互相ping通、使用：ping 容器IP === 能互相ping通

案例

命令

network

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

ls、inspect - docker所有网络、详细查看具体的某个网络信息

//查看ls的使用文档
docker network ls --help


//默认会创建3大网络模式，如下图
docker network ls

//查看inspect使用文档
docker network inspect  --help

//查看网络详细信息
docker network inspect 网络ID

 
查看系统所有网络相关

---

 
查看某个网络详细信息相关

create、rm - docker中创建、删除网络

//网络创建使用文档
docekr network create --help

//默认 桥接模式
docekr network create 新网络名字

//网络删除使用文档
docekr network rm --help

docekr network rm 网络的ID

 
创建网络相关

---

 
删除网络相关

容器编排-compose

概述

解决： Docker容器集群的快速编排 — 很多容器间启动顺序、网络通信的调用等等的管理
 
docker-compose.yml： 写好多个容器之间的调用关系。只用一个命令就可同时启动、关闭这些容器
 
compose命令官网： https://docs.docker.com/compose/reference/
 
compose文件官网： https://docs.docker.com/compose/compose-file/
 
安装注意： 根据最新的官网下载docker，docker-compose会内置集成为成docker一个基础命令
安装官网： https://docs.docker.com/engine/install/centos/

定义多个容器的编排

docker-compose核心概念

一文件：docker-compose.yml

两要素

服务：多个应用容器实例

工程：由多个容器实例组成的一个完整业务单元

容器编排使用步骤

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

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

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

命令

概述

# 帮助文档
docker compose --help

# docker-compose版本
docker compose version


# 检测当前目录下docker-compose.yml语法是否正确 == 结果没任何消息说明语法正确
# 下面两个命令是一样的
docker compose config -q
docker compose convert -q

# 基于当前目录的docker-compose.yml启动一系列容器
docker compose up -d

简单Demo演示

Springboot项目

项目结构

pom.xml

<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.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.7.2version>
        <relativePath/> 
    parent>
    <groupId>work.linruchanggroupId>
    <artifactId>docker-springboot-testartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>docker-springboot-testname>
    <description>docker-springboot-testdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>

        
        <dependency>
            <groupId>com.github.xiaoymingroupId>
            <artifactId>knife4j-spring-boot-starterartifactId>
            <version>3.0.3version>
        dependency>



        
        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>5.8.4version>
        dependency>

        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>3.5.2version>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.29version>
        dependency>


        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
            <version>2.7.2version>
        dependency>

        
        <dependency>
            <groupId>p6spygroupId>
            <artifactId>p6spyartifactId>
            <version>3.9.1version>
        dependency>





        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-configuration-processorartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombokgroupId>
                            <artifactId>lombokartifactId>
                        exclude>
                    excludes>
                configuration>
            plugin>
        plugins>
    build>

project>

 
application.yml

server:
  port: 8080

# 数据库设置
spring:
  datasource:
    username: root
    password: root
#    url: jdbc:p6spy:mysql://192.168.19.107:3306/lrc_blog?useSSL=false&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    url: jdbc:p6spy:mysql://mysql:3306/lrc_blog?useSSL=false&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
  redis:
#    host: 192.168.19.107
    host: redis
    port: 6379
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher



# mybatisplus设置
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    map-underscore-to-camel-case: true
    cache-enabled: true
  mapper-locations: classpath:mapper/*Mapper.xml
  global-config:
    db-config:
      id-type: assign_uuid
      logic-delete-value: 1
      logic-not-delete-value: 0
      logic-delete-field: is_del
      where-strategy: not_empty  #不where非empty的字段【空字符、null值】
      update-strategy: not_empty
      insertStrategy: not_empty

 
SpringConfig.yml

@Configuration
@EnableSwagger2
public class SpringConfig {


    @Bean(value = "defaultApi2")
    public Docket defaultApi2() {
        Docket docket = new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(new ApiInfoBuilder()
                        //.title("swagger-bootstrap-ui-demo RESTful APIs")
                        .description("# swagger-bootstrap-ui-demo RESTful APIs")
                        .termsOfServiceUrl("http://www.xx.com/")
                        .contact(new Contact("[email protected]","[email protected]","[email protected]"))
                        .version("1.0")
                        .build())
                //分组名称
                .groupName("2.X版本")
                .select()
                //这里指定Controller扫描包路径
                .apis(RequestHandlerSelectors.basePackage("work.linruchang.dockerspringboottest"))
                .paths(PathSelectors.any())
                .build();
        return docket;
    }

}

 
IndexController.yml

@RestController
public class IndexController {

    @Autowired
    Environment environment;

    @GetMapping
    public Dict getInfo() {

        return Dict.create()
                .set("name", "lrc")
                .set("port", environment.getProperty("server.port"));
    }

}

 
UserController.yml

@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    VUserService vUserService;

    private final String redis_user_key = "user_";

    @GetMapping("/{userId}")
    public Object getUserById(@PathVariable("userId") Long userId) {

        String redisKey = redis_user_key + userId;

        VUser user = (VUser) redisTemplate.opsForValue().get(redisKey);
        if( user == null ) {
            user = vUserService.getById(userId);
            if(user != null) {
                redisTemplate.opsForValue().set(redisKey,user);
                return user;
            }
        }
        return user;
    }



}

docker-compose文件编写

docker-compose.yml

version: "3"

services:
  microService:
    image: my-spring-boot:2.0
    container_name: my-spring-boot-redis-mysql
    ports:
      - "8080:8080"
    volumes:
      - /app/microService:/data
    networks:
      - lrcMicroService
    depends_on:
      - redis
      - mysql

  redis:
    image: redis:latest
    container_name: redis
    ports:
      - "6379:6379"
    volumes:
      - /www/server/redis/redis.conf:/etc/redis/redis.conf
      - /www/server/redis/data:/data
    networks:
      - lrcMicroService
    command:
      - redis-server
      - /etc/redis/redis.conf

  mysql:
    image: mysql:latest
    container_name: mysql
    ports:
      - "3306:3306"
    volumes:
      - /www/server/mysql/conf.d:/etc/mysql/conf.d
      - /www/server/mysql/data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: 'root'

    networks:
      - lrcMicroService


networks:
  lrcMicroService:

启动项目、浏览器测试、停止项目

//基于docker-compose.yml启动项目
docker compose up -d 

//基于docker-compose.yml删除容器，停止项目
docker compose down