Créez un système de microservices Spring Cloud distribué et hautement disponible

Avec le développement continu du commerce Internet, l'architecture des microservices est devenue la méthode d'architecture privilégiée pour de plus en plus d'entreprises. En tant que framework de microservices basé sur Spring Boot, Spring Cloud présente les caractéristiques de distribution et de haute disponibilité. De plus en plus d'entreprises commencent à l'utiliser pour créer leurs propres systèmes de microservices.

Cet article explique comment utiliser Spring Cloud pour créer un système de microservices distribués et hautement disponibles.

1. Construire le centre d'enregistrement

Le centre d'enregistrement est l'un des composants essentiels de l'architecture des microservices Spring Cloud. Tous les microservices doivent enregistrer leurs propres informations auprès du centre d'enregistrement, puis d'autres services peuvent trouver ce service via l'enregistrement. centre. Dans Spring Cloud, Eureka est un très excellent composant de centre d'enregistrement. Il a des caractéristiques de haute disponibilité, distribuées et autres, et peut répondre aux besoins de divers scénarios. Par conséquent, nous avons choisi d'utiliser Eureka pour créer le centre d'enregistrement.

Avant d'utiliser Eureka pour créer un centre d'enregistrement, nous devons comprendre certains concepts de base d'Eureka :

1. Eureka Server : le côté serveur d'Eureka, utilisé pour accepter les informations d'enregistrement des clients et maintenir une liste d'informations sur les instances de service.
2. Eureka Client : le client d'Eureka, utilisé pour enregistrer ses propres services auprès d'Eureka Server.
3. Instance de service : une instance en cours d'exécution d'un microservice. L'instance de service contient l'adresse IP, le numéro de port, l'état de santé et d'autres informations du service.

Les étapes pour utiliser Eureka pour créer un centre d'inscription sont les suivantes :

1. Créez un nouveau projet Spring Boot.
2. Ajouter des dépendances : ajoutez les dépendances suivantes dans l'annotation pom. EnableEurekaServer, utilisée pour démarrer le service Eureka :

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

Grâce aux étapes ci-dessus, nous avons réussi à créer un centre d'enregistrement basé sur Eureka. Nous pouvons saisir http://localhost:8761 dans le navigateur pour accéder à la console Eureka Server et constater qu'aucun service n'est actuellement enregistré sur Eureka Server.
3. 2. Créer un fournisseur de services

Un fournisseur de services est un microservice qui met en œuvre une activité spécifique. Il enregistrera ses propres informations auprès du centre d'enregistrement afin que d'autres microservices puissent le découvrir et appeler les services qu'il fournit.
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. 在启动类中添加@EnableZuulProxyNous utilisons ici un exemple simple pour créer un fournisseur de services HTTP capable d'accepter les requêtes HTTP et de renvoyer une chaîne.

Les étapes pour créer un fournisseur de services à l'aide de Spring Cloud sont les suivantes :

Créez un nouveau projet Spring Boot.

Ajouter des dépendances : ajoutez les dépendances suivantes dans le pom. ：

🎜

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    #设置服务提供者名称

🎜Ajoutez l'annotation @EnableDiscoveryClient dans la classe de démarrage pour activer la fonction de découverte de service : 🎜 🎜

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

🎜Grâce aux étapes ci-dessus, nous avons réussi à créer un fournisseur de services. Nous pouvons saisir http://localhost:8080/test dans le navigateur pour accéder aux services qu'il fournit. Si tout est normal, nous pouvons voir la valeur de retour de Hello World. 🎜🎜3. Créer un consommateur de services🎜🎜Un consommateur de services est un microservice qui appelle les services fournis par d'autres microservices. Il interroge le centre d'enregistrement pour les microservices requis, puis appelle les services fournis par les microservices. 🎜🎜Les étapes pour utiliser Spring Cloud pour créer un consommateur de services sont les suivantes : 🎜🎜🎜Créez un nouveau projet Spring Boot. 🎜🎜Ajouter des dépendances : ajoutez les dépendances suivantes dans le pom.
🎜Ajoutez une classe Controller pour exposer l'interface de service : 🎜🎜

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

🎜Ajoutez le @ Annotation EnableDiscoveryClient dans la classe de démarrage pour la fonction Activer la découverte de services : 🎜🎜

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分支

🎜Grâce aux étapes ci-dessus, nous avons réussi à créer un consommateur de service, qui peut appeler le service du fournisseur de services et renvoyer le résultat correct. 🎜🎜4. Construire une passerelle API🎜🎜La passerelle API est l'entrée du système de microservices. Elle joue plusieurs rôles tels que le routage, l'équilibrage de charge et le contrôle de sécurité. Dans Spring Cloud, Zuul est un excellent composant de passerelle API qui peut répondre à nos différents besoins. 🎜🎜Les étapes pour créer une passerelle API à l'aide de Spring Cloud sont les suivantes : 🎜🎜🎜Créez un nouveau projet Spring Boot. 🎜🎜Ajouter des dépendances : ajoutez les dépendances suivantes dans le fichier pom. , utilisé pour activer la fonction proxy Zuul : 🎜🎜

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

🎜Grâce aux étapes ci-dessus, nous avons réussi à créer une passerelle API, qui peut transférer le http://localhost:8888. /test demande au fournisseur de services et renvoie le résultat correct. 🎜🎜5. Construire un centre de configuration🎜🎜Le centre de configuration peut gérer de manière centralisée les informations de configuration dans le système de microservices, nous pouvons configurer le système plus facilement. 🎜

在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网关和配置中心。在实际应用过程中，我们可以通过这些组件自由组合，构建出更加复杂、高效的微服务体系。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!