前言

本文将介绍使用Eureka搭建微服务的流程，一步一步的从零开始搭建，大概有以下搭建流程：
1、Rest微服务工程搭建
2、单机Eureka构建
3、集群Eureka构建步骤
通过这三个流程，这三个流程后者总是在前者的基础上，展示一个简单Eureka微服务的搭建过程。

1、Rest微服务工程搭建

1.1先创建一个父工程

先创建一个空的父工程
在这里插入图片描述
圈中的那三个modul，是后来创建的，刚创建的父工程是啥也没有，只有pom.xml文件

1.2修改xml

作为父工程，主要是用于统一管理maven依赖，统一版本号，也是便于管理我们建立的多个modul。这里，我们需要改动一下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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.atguigu.cloud</groupId>
    <artifactId>springCloud2020</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--父工程打包为pom-->
    <packaging>pom</packaging>

    <!-- 统一管理jar包版本 -->
    <properties>
        <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.21</druid.version>
        <mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
    </properties>

    <!-- 子模块继承之后，提供作用：锁定版本+子modlue不用写groupId和version  -->
    <dependencyManagement>
        <dependencies>
            <!--spring boot 2.2.2-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.2.2.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud Hoxton.SR1-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Hoxton.SR1</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!--spring cloud alibaba 2.1.0.RELEASE-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>2.1.0.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.spring.boot.version}</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>${junit.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

</project>

需要注意的几点，要将打包方式改为pom。
还要明白一点< dependencyManagement> 和< /dependencies>的作用：maven使用dependencyManagement来提供一种管理依赖版本号的方式，在pom.xml中使用dependencyManagement元素，能让所有子项目中引入依赖时不需要显式的列出版本号。maven会沿着父子层次向上查找dependencyManagement，并使用其中声明的依赖版本号。
dependencyManagement里只是声明依赖，并不实现引入，因此子项目还需要显示的声明所需要的依赖
这样做的好处就是: 如果有多个子项目都引用同一样的依赖,则可以避免在每个使用的子项目里都声明一个版本号,这样想升级或切换到另一个版本时,只需在顶层父容器里更新,而不需要一个一个子项目的修改l;另外如果某个子项目需要另外的一个版本,只需声明version版本

1.3创建服务提供者

在父工程下创建一个module子项目，作为服务的提供者Cloud-provider-payment8001:
在这里插入图片描述

这个子项目比较简单，创建后的项目结构如上图，也只是平常的增删改查，没啥好说的。
yml配置：

server:
  port: 8001

  datasource:
    #当前数据源操作类型
    type: com.alibaba.druid.pool.DruidDataSource
    #mysql驱动包
    driver-class-name: org.gjt.mm.mysql.Driver
    url: jdbc:mysql://localhost:3306/cloud2020?useUnicode=true&characterEncoding=utf8&useSSL=false
    username: root
    password: 123456


mybatis:
  mapperLocations: classpath:mapper/*.xml
  #所有entity别名类所在包
  type-aliases-package: com.george.springcloud.entities

pom.xml:

<?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">
    <parent>
        <artifactId>springCloud2020</artifactId>
        <groupId>com.atguigu.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>Cloud-provider-payment8001</artifactId>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-jdbc -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.atguigu.cloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

</project>

创建流程：创建module->改pom->创建yml->创建主启动类
测试结果：
在这里插入图片描述

1.4创建服务消费者

同样的创建流程：创建module->改pom->创建yml->创建主启动类
在这里插入图片描述
yml:

server:
  port: 80

pom.xml:

<?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">
    <parent>
        <artifactId>springCloud2020</artifactId>
        <groupId>com.atguigu.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-consumer-order80</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.atguigu.cloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>
</project>

服务消费者，也比较简单，需要注意的以下几点：
需要创建的配置类：

@Configuration
public class ApplicationContextConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

将我们的RestTemplate注册到容器中，是spring为我们提供的一个调用微服务接口的模板方法，它就负责了调用我们的消费者。
使用如下：

@RestController
@Slf4j
public class OrderController {

    public static final String PAYMENT_URL = "http://localhost:8001";

    @Resource
    private RestTemplate restTemplate;

    @GetMapping(value = "/consumer/payment/create")
    public CommonResult<Payment> create(Payment payment) {
        return restTemplate.postForObject(PAYMENT_URL + "/payment/create", payment, CommonResult.class);
    }

    @GetMapping("/consumer/payment/get/{id}")
    public CommonResult<Payment> getPayment(@PathVariable("id") Long id) {
        return restTemplate.getForObject(PAYMENT_URL + "/payment/get/" + id, CommonResult.class);
    }

}

测试结果：
在这里插入图片描述

1.5公共包

为了防止大家误会，我也把这个子项目贴出来
在这里插入图片描述
这个项目只是存放了一些公共的实体类，供消费者和提供者使用，它不需要配置yml和启动类，只需要打包到仓库，在需要用的地方引入依赖即可。

小结

如此，第一个流程，就算是搭建好了。当前这个Rest微服务工程比较简单，但还与Eureka一点关系也没有，它是后面搭建的基础。
最后，补充一点，我们回头再看父工程的pom：
在这里插入图片描述
随着，我们子项目的创建，这里的module会越来越多，大家了解一下即可。

2、单机Eureka构建

接下来，我们在第一个流程的基础上引入Eureka，改造成一个简单的单机微服务。

Eureka的基础知识

什么是服务治理？
传统的rpc调用，管理每一个服务与服务之间的依赖的关系比较复杂，管理比较复杂，所以需要服务治理，管理服务与服务的依赖关系，可实现服务调用，负载均衡，容错等，实现服务的注册与注册

什么是服务的注册与发现？
eureka采用cs的设计架构，eureka作为服务的注册功能的服务器，他是服务注册的中心，而系统中的其他的微服务使用eureka的client连接到eureka server并维持心跳检测，
在服务的注册与发现中，有一个注册中心，当服务器启动的时候会把当前的自己的服务器的信息，比如服务器地址，通讯地址等以别名注册的方式注册到注册中心（key (别名)value（host:port））。另一方（消费者|服务提供者）以该别名的方式去注册中心获取到实际的通讯地址，然后在体现本地rpc调用rpc远程调用框架的核心设计思想：在于注册中心，因为使用注册中心管理每个服务与服务之间的依赖关系（服务治理理念）,在人格rpc远程框架中，都会有一个注册中心（存放服务器地址的相关信息）
在这里插入图片描述
1，启动eureka注册中心
2，启动服务提供者
3，服务提供者启动后将自身信息以别名的方式注册到eureka
4，消费者在需要调用接口的时候，使用服务别名去注册中心获取实际的rpc服务远程调用地址
5，消费者获取调用地址后底层使用利用HttpClient技术实现远程调用
6，消费者获取服务地址后会缓存到jvm内存中，默认每三十秒更新一次服务调用地址

eureka 的两个组件
eureka server:提供服务的注册服务，
eureka client:通过注册中心访问，是一个java客户端，客户端同时也具备一个内置的使用轮询（round-robin）负载算法的负载均衡器，在应用启动后，将会向eureka server发送心跳，默认周期30s，如果eureka server在多个心跳周期没有接收到某个节点的心跳，eureka将会从服务注册表中把这个服务移除（默认90s）

2.1EurekaServer端服务注册中心

由上述的基础知识，我们知道要实现微服务架构，就需要有一个服务注册中心。因此我们需要创建一个新的module，如下
cloud-eureka-server7001：
在这里插入图片描述
pom.xml:

<?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">
    <parent>
        <artifactId>springCloud2020</artifactId>
        <groupId>com.atguigu.cloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>cloud-eureka-server7001</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <!-- boot web actuator -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>


    </dependencies>

</project>

其中引入了eureka的依赖。

yml：

server:
  port: 7001


eureka:
  instance:
    #eureka服务端的实例名称
    hostname: localhost
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心,职责是维护实例,并不需要检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

主启动类：

@SpringBootApplication
@EnableEurekaServer
public class EurekaMain7001 {
    public static void main(String[] args) {
        SpringApplication.run(EurekaMain7001.class,args);
    }
}

需要加上开启eureka服务注册中心的注解。

测试：
在这里插入图片描述
这就已经搭好我们的服务注册中心了，可见当前服务注册中心未注册任何服务。

2.2改造服务提供者

为了将我们的服务提供者注册到服务中心，我们需要做以下改造。

修改pom，加入依赖：

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

注意，引入的是client端。
修改yml：

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka  #单机版

改造启动类

@SpringBootApplication
@EnableEurekaClient
public class PaymentMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain8001.class, args);
    }
}

只是添加了一个注解@EnableEurekaClient

测试
在这里插入图片描述
可见，我们的服务已经注册进去了，服务名既是我们yml里配置的。

2.3改造服务消费者

同样的，我们也将我们的消费者注册到服务中心去。
改pom

       <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

改yml

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
      defaultZone: http://localhost:7001/eureka  #单机版

主启动类
加上注解@EnableEurekaClient
改controller

//    public static final String PAYMENT_URL = "http://localhost:8001";
    public static final String PAYMENT_URL = "http://CLOUD-PAYMENT-SERVICE";

改为通过服务名，去查找服务。到这一步，还不能测试，如果运行了，我们会发现，报错：找不到服务，因为，80消费者根据服务名去服务中心查找服务时，消费者默认的认为被注册到服务中心的提供者是有多个（即是集群，即便你只注册了一个），所有还要加上一个配置如下
改ApplicationContextConfig
需要加上负载均衡的注解

@Configuration
public class ApplicationContextConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

负载均衡的默认策略是轮询，但当前注册中心只有一个消费者，所有无论怎么轮询都是它。
测试
在这里插入图片描述
在这里插入图片描述

2.4小结

以上就已经完成了，单机版的微服务搭建。

3、集群Eureka构建

为什么要搭建集群

因为服务注册中心，在微服务的整个架构来说，是最核心的也是最重要的，若是它出了故障，就会导致整个微服务架构系统崩溃，所有搭建集群是很有必要的，实现高可用。

搭建Eureka服务注册中心集群

为了在我们的电脑本机，实现集群搭建，我们要修改hosts文件的映射配置如下：
在这里插入图片描述

创建一个新的项目cloud-eureka-server7002：
在这里插入图片描述
与7001相似，只是端口号不同。
yml：

server:
  port: 7002


eureka:
  instance:
    #eureka服务端的实例名称
    hostname: eureka7002.com
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心,职责是维护实例,并不需要检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://eureka7001.com:7002/eureka/

修改cloud-eureka-server7001的yml：

server:
  port: 7001


eureka:
  instance:
    #eureka服务端的实例名称
    hostname: eureka7001.com
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心,职责是维护实例,并不需要检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://eureka7002.com:7002/eureka/

要注意这个配置defaultZone，它们是互相配置了彼此，实现互相注册，相互守望。这个配置是实现集群的要点。
测试
在这里插入图片描述
访问7001的服务中心，可以看到，它关联了7002。
到这里，我们就已经实现了服务中心的集群了。

搭建服务提供者集群

创建新的Cloud-provider-payment8002，内容与Cloud-provider-payment8001一致，只是端口号不同。
只需要修改两者的yml即可，yml配置是相同的：

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka  #单机版
      defaultZone:  http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka

如此就行了。

小结

到这里，集群已经搭好了，已经实现了服务中心集群，提供者服务集群。

actuator微服务信息完善

在这里插入图片描述
这里介绍一下监视器页面的信息设置，我们看下图，服务对应的实例名显示了我们电脑的主机名，我们若想去掉可以添加一个配置

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka  #单机版
      defaultZone:  http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
   #定义实例名
  instance:
    instance-id: payment8001 #定义实例名
    prefer-ip-address: true #访问路径显示ip

在这里插入图片描述

eureka自我保护

概念

保护模式
主要用于一组客户端和Eureka Server之间网络存在网络分区场景下的保护，一旦进入保护的模式，Eureka Server 将会尝试保护其服务表的信息，不再删除服务注册表的数据，也就是不会注销任何微服务
导致原因： 某时刻某一个微服务不可用了，Eureka不会立刻清理，依旧会对该服务的信息进行保存，属于CAP里面的AP的分支

为什么会产生Eureka自我保护机制？
为了防止Eureka Client可以正常运行，但是与Eureka网络不通，Eureka不会立刻将Eureka服务剔除

什么是自我保护？
如果Eureka Server 在一定的时间没有接受到某个微服务实例的心跳，Eureka Server立刻将会注销该实例，默认90s，但是当网路分区发生故障的时候（卡顿，延时，拥挤），微服务无法与Eureka之间通信，其实微服务是健康的，此时不应该注销客户。

关闭自我保护

Eureka 服务注册中心的出产默认是开启自我保护机制的。
修改Eureka 服务注册中心的配置

server:
  port: 7002


eureka:
  instance:
    #eureka服务端的实例名称
    hostname: eureka7002.com
  client:
    #false表示不向注册中心注册自己
    register-with-eureka: false
    #false表示自己端就是注册中心,职责是维护实例,并不需要检索服务
    fetch-registry: false
    service-url:
      #设置与Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://eureka7001.com:7001/eureka/
  server:
    # 关闭自我保护机制，保证不可用服务被及时剔除.默认开启保护机制 true
    enable-self-preservation: false
    eviction-interval-timer-in-ms: 2000 #设置为2000ms内没接收到心跳，就将服务剔除

上述配置，就是将服务注册中心的自我保护机制关闭，并设置为2000ms内没接收到服务心跳，就将目标服务剔除。
修改Eureka 客户端的配置

eureka:
  client:
    #是否将自己注册到注册中心, 默认true
    register-with-eureka: true
    #是否从EurekaServer抓取已有的注册信息,单机无所谓,集群必须设置为true配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
#      defaultZone: http://localhost:7001/eureka  #单机版
      defaultZone:  http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
  instance:
    instance-id: payment8001 #定义实例名
    prefer-ip-address: true #访问路径显示ip
    #Eureka客户端向服务端发送心跳的时间间隔.单位为秒(默认30 秒)
    lease-renewal-interval-in-seconds: 1
    #Eureka服务端在收到最后一次心跳等待时间上限.单位为秒(默认90 秒),超时将剔除服务
    lease-expiration-duration-in-seconds: 2

上述配置，设置了Eureka客户端向服务端发送心跳的时间间隔.单位为秒(默认30 秒)，Eureka服务端在收到最后一次心跳等待时间上限.单位为秒(默认90 秒),超时将剔除服务。

# java # spring cloud
Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生