Erstellen Sie ein verteiltes, hochverfügbares Spring Cloud-Microservice-System

Mit der kontinuierlichen Entwicklung des Internetgeschäfts ist die Microservice-Architektur für immer mehr Unternehmen zur bevorzugten Architekturmethode geworden. Als auf Spring Boot basierendes Microservice-Framework weist Spring Cloud die Merkmale der Verteilung und Hochverfügbarkeit auf. Immer mehr Unternehmen beginnen damit, ihre eigenen Microservice-Systeme aufzubauen.

In diesem Artikel erfahren Sie, wie Sie mit Spring Cloud ein hochverfügbares, verteiltes Microservice-System aufbauen.

1. Erstellen Sie das Registrierungscenter

Das Registrierungscenter ist eine der Kernkomponenten der Spring Cloud-Microservice-Architektur. Alle Microservices müssen ihre eigenen Informationen beim Registrierungscenter registrieren, und dann können andere Dienste diesen Service durch die Registrierung finden Center. In Spring Cloud ist Eureka eine hervorragende Komponente für das Registrierungszentrum. Es verfügt über hohe Verfügbarkeit, verteilte Funktionen und andere Eigenschaften und kann die Anforderungen verschiedener Szenarien erfüllen. Daher haben wir uns für die Verwendung von Eureka zum Aufbau des Registrierungszentrums entschieden.

Bevor wir Eureka zum Aufbau eines Registrierungszentrums verwenden, müssen wir einige grundlegende Konzepte von Eureka verstehen:

1. Eureka-Server: Die Serverseite von Eureka, die zum Empfangen von Registrierungsinformationen von Clients und zum Verwalten einer Informationsliste von Dienstinstanzen verwendet wird.
2. Eureka-Client: Der Eureka-Client, der zur Registrierung seiner eigenen Dienste beim Eureka-Server verwendet wird.
3. Dienstinstanz: Eine laufende Instanz eines Mikrodienstes. Die Dienstinstanz enthält die IP-Adresse, die Portnummer, den Gesundheitsstatus und andere Informationen des Dienstes.

Die Schritte zum Erstellen eines Registrierungszentrums mit Eureka sind wie folgt:

1. Erstellen Sie ein neues Spring Boot-Projekt.
2. Abhängigkeiten hinzufügen: Fügen Sie die folgenden Abhängigkeiten in der Annotation „EnableEurekaServer“ hinzu, die zum Starten des Eureka-Dienstes verwendet wird:

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

Durch die oben genannten Schritte haben wir erfolgreich ein Registrierungscenter basierend auf Eureka erstellt. Wir können http://localhost:8761 in den Browser eingeben, um auf die Eureka Server-Konsole zuzugreifen und zu sehen, dass derzeit keine Dienste bei Eureka Server registriert sind.
2. Erstellen Sie einen Dienstanbieter. Ein Dienstanbieter ist ein Mikrodienst, der ein bestimmtes Geschäft implementiert. Er registriert seine eigenen Informationen beim Registrierungszentrum, damit andere Mikrodienste sie entdecken und die von ihm bereitgestellten Dienste aufrufen können.

Wir verwenden hier ein einfaches Beispiel, um einen HTTP-Dienstanbieter zu erstellen, der HTTP-Anfragen akzeptieren und einen String zurückgeben kann.
4. @EnableEurekaServer注解，用于启动Eureka服务：

server:
  port: 8761    #设置服务端口号

eureka:
  instance:
    hostname: localhost    #设置Eureka Server的主机名
  client:
    register-with-eureka: false    #设置是否注册自身服务，默认为true，这里设置为false
    fetch-registry: false    #设置是否获取注册列表，默认为true，这里设置为false
  server:
    enable-self-preservation: false    #设置是否启用自我保护机制，默认为true，这里设置为false

通过以上的步骤，我们就成功构建了一个基于Eureka的注册中心。我们可以在浏览器中输入http://localhost:8761访问Eureka Server的控制台，看到当前没有任何服务注册到Eureka Server中。

二、 构建服务提供者

服务提供者是实现具体业务的微服务，它会向注册中心注册自己的信息，让其他的微服务能够发现它并调用它提供的服务。

我们在这里使用一个简单的示例，构建一个HTTP服务提供者，它能够接受HTTP请求，并返回一个字符串。

使用Spring Cloud构建服务提供者的步骤如下：

1. 新建一个Spring Boot项目。
2. 添加依赖：在pom.xml文件中添加如下依赖：

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

3. 在application.yml文件中添加如下配置：

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

4. 新建一个Controller类，并在其中添加一个返回字符串的接口：

server:
  port: 8080    #设置服务端口号

spring:
  application:
    name: test-service    #设置服务名称，用于注册到Eureka Server中

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/    #设置Eureka Server地址

5. 在启动类中添加@EnableDiscoveryClient注解，用于启用服务发现功能：

@RestController
public class TestController {
    @GetMapping("/test")
    public String test() {
        return "Hello World";
    }
}

通过以上的步骤，我们就成功构建了一个服务提供者。我们可以在浏览器中输入http://localhost:8080/test访问它提供的服务，如果一切正常，就可以看到Hello World的返回值。

三、 构建服务消费者

服务消费者是调用其他微服务提供的服务的微服务，它会向注册中心查询需要的微服务，然后调用该微服务提供的服务。

使用Spring Cloud构建服务消费者的步骤如下：

1. 新建一个Spring Boot项目。
2. 添加依赖：在pom.xml文件中添加如下依赖：

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

3. 在application.yml文件中添加如下配置：

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

4. 添加一个Service类，用于调用服务提供者:

server:
  port: 8090    #设置服务端口号

spring:
  application:
    name: test-consumer    #设置服务名称

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/    #设置Eureka Server地址

5. 添加一个Controller类，用于暴露服务接口：

@Service
public class TestService {
    @Autowired
    private RestTemplate restTemplate;

    @HystrixCommand(fallbackMethod = "fallback")
    public String test() {
        return restTemplate.getForObject("http://test-service/test", String.class);
    }

    public String fallback() {
        return "fallback";
    }
}

6. 在启动类中添加@EnableDiscoveryClient注解，用于启用服务发现功能：

@RestController
public class TestController {
    @Autowired
    private TestService testService;

    @GetMapping("/test")
    public String test() {
        return testService.test();
    }
}

通过以上的步骤，我们就成功构建了一个服务消费者，它可以调用服务提供者的服务并返回正确的结果。

四、 构建API网关

API网关是微服务体系的入口，它起到了路由、负载均衡、安全控制等多种作用。在Spring Cloud中，Zuul是一个优秀的API网关组件，可以满足我们的各种需求。

使用Spring Cloud构建API网关的步骤如下：

1. 新建一个Spring Boot项目。
2. 添加依赖：在pom.xml文件中添加如下依赖：

@SpringBootApplication
@EnableDiscoveryClient
@EnableCircuitBreaker    #启用熔断器功能
public class TestConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestConsumerApplication.class, args);
    }

    @Bean
    @LoadBalanced    #启用负载均衡功能
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

3. 在application.yml文件中添加如下配置：

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

4. 在启动类中添加@EnableZuulProxyDie Schritte zum Aufbau eines Dienstanbieters mit Spring Cloud sind wie folgt:

Erstellen Sie ein neues Spring Boot-Projekt.

Abhängigkeiten hinzufügen: Fügen Sie die folgenden Abhängigkeiten im POM hinzu:

server:
  port: 8888    #设置服务端口号

spring:
  application:
    name: api-gateway    #设置服务名称

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/    #设置Eureka Server地址

zuul:
  routes:
    test-service:
      path: /test/**
      serviceId: test-service    #设置服务提供者名称

Fügen Sie die Annotation @EnableDiscoveryClient in der Startup-Klasse hinzu: 🎜 🎜

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

🎜Durch die oben genannten Schritte haben wir erfolgreich einen Dienstleister aufgebaut. Wir können http://localhost:8080/test in den Browser eingeben, um auf die bereitgestellten Dienste zuzugreifen. Wenn alles normal ist, können wir den Rückgabewert von Hello World sehen. 🎜🎜3. Erstellen Sie einen Service-Consumer🎜🎜Ein Service-Consumer ist ein Microservice, der von anderen Microservices bereitgestellte Services aufruft. Er fragt das Registrierungscenter nach den erforderlichen Microservices ab und ruft dann die von den Microservices bereitgestellten Services auf. 🎜🎜Die Schritte zum Erstellen eines Service-Consumers mit Spring Cloud sind wie folgt: 🎜🎜🎜Erstellen Sie ein neues Spring Boot-Projekt. 🎜🎜Abhängigkeiten hinzufügen: Fügen Sie die folgenden Abhängigkeiten im POM hinzu: 🎜🎜

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

🎜Fügen Sie den @ hinzu. EnableDiscoveryClient-Annotation in der Startup-Klasse für die Funktion „Service Discovery aktivieren“: 🎜🎜

server:
  port: 8888    #设置服务端口号

spring:
  application:
    name: config-server    #设置服务名称

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/    #设置Eureka Server地址

# 配置中心
spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/{username}/{repository}.git    #设置git仓库地址
          username: {username}    #设置git用户名
          password: {password}    #设置git密码
          search-paths: respo1A/config, respo1B/config    #设置配置文件搜索路径
          default-label: main    #设置git分支

🎜Durch die oben genannten Schritte haben wir erfolgreich einen Service-Consumer erstellt, der den Service des Service-Providers aufrufen und das richtige Ergebnis zurückgeben kann. 🎜🎜4. Erstellen Sie ein API-Gateway. Das API-Gateway ist der Eingang zum Microservice-System. Es spielt mehrere Rollen wie Routing, Lastausgleich und Sicherheitskontrolle. In Spring Cloud ist Zuul eine hervorragende API-Gateway-Komponente, die unsere verschiedenen Anforderungen erfüllen kann. 🎜🎜Die Schritte zum Erstellen eines API-Gateways mit Spring Cloud sind wie folgt: 🎜🎜🎜Erstellen Sie ein neues Spring Boot-Projekt. 🎜🎜Abhängigkeiten hinzufügen: Fügen Sie die folgenden Abhängigkeiten im POM hinzu, die zum Aktivieren der Zuul-Proxy-Funktion verwendet werden: 🎜🎜

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

🎜Durch die oben genannten Schritte haben wir erfolgreich ein API-Gateway erstellt, das http://localhost:8888 weiterleiten kann /test-Anfrage an den Dienstanbieter senden und das korrekte Ergebnis zurückgeben. 🎜🎜5. Erstellen Sie ein Konfigurationscenter🎜🎜Das Konfigurationscenter kann die Konfigurationsinformationen im Microservice-System zentral verwalten. Über das Konfigurationscenter können wir das System bequemer konfigurieren. 🎜

在Spring Cloud中，Config Server是一个优秀的配置中心组件，它可以与Eureka、Zuul等组件配合使用，构建一个完整的微服务体系。

使用Spring Cloud构建配置中心的步骤如下：

1. 新建一个Spring Boot项目。
2. 添加依赖：在pom.xml文件中添加如下依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-config-server</artifactId>
</dependency>

3. 在application.yml文件中添加如下配置：

server:
  port: 8888    #设置服务端口号

spring:
  application:
    name: config-server    #设置服务名称

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/    #设置Eureka Server地址

# 配置中心
spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/{username}/{repository}.git    #设置git仓库地址
          username: {username}    #设置git用户名
          password: {password}    #设置git密码
          search-paths: respo1A/config, respo1B/config    #设置配置文件搜索路径
          default-label: main    #设置git分支

4. 在启动类中添加@EnableConfigServer注解，用于启用Config Server功能：

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

通过以上的步骤，我们就成功构建了一个Config Server。我们可以将配置文件上传到git仓库中，然后通过http://localhost:8888/application-dev.properties的方式获取指定的配置文件。

六、 总结

通过以上的步骤，我们成功地构建了一个高可用、分布式的Spring Cloud微服务体系，包括了注册中心、服务提供者、服务消费者、API网关和配置中心。在实际应用过程中，我们可以通过这些组件自由组合，构建出更加复杂、高效的微服务体系。

Das obige ist der detaillierte Inhalt vonErstellen Sie ein verteiltes, hochverfügbares Spring Cloud-Microservice-System. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!