Comment utiliser Spring Cloud pour créer un cluster de microservices hautes performances

Avec l'essor du cloud computing et des microservices, de plus en plus d'entreprises commencent à rechercher une architecture distribuée et hautement disponible pour créer leurs propres applications, et Spring Cloud est l'un des leaders dans ce domaine. Spring Cloud fournit une multitude de composants et de services pour créer rapidement des systèmes distribués et déployer facilement ces services sur la plateforme cloud. Dans cet article, je vais vous présenter comment utiliser Spring Cloud pour créer un cluster de microservices hautes performances.

1. Créer une architecture de microservices

Avant de commencer à créer notre système de microservices, passons en revue ce que sont les microservices. Les microservices sont un modèle architectural qui divise une application en petits services qui collaborent les uns avec les autres au sein du système global. Il permet aux développeurs de créer et de publier rapidement des applications distribuées et évolutives.

Spring Cloud fournit un ensemble d'outils et de frameworks pour prendre en charge l'architecture des microservices, y compris, mais sans s'y limiter, l'enregistrement des services, la découverte de services, l'équilibrage de charge et la configuration distribuée, etc. Voici les étapes pour implémenter des microservices à l'aide de Spring Cloud :

1) Créer un serveur Eureka

Eureka est l'un des composants de découverte de services préférés dans Spring Cloud. Il s'agit d'un service basé sur REST qui peut nous aider à gérer les dépendances des microservices. . Pour utiliser Eureka, vous devez d'abord configurer un serveur Eureka. Vous pouvez créer un serveur Eureka en utilisant le code suivant :

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

Après avoir démarré l'application, vous pouvez accéder à la console Eureka via http://localhost:8761/ et afficher tous les microservices enregistrés.

2) Créer des microservices

Maintenant, nous allons créer deux microservices : l'un est le service utilisateur et l'autre est le service de commande. Le service utilisateur assurera la fonction d'ajout, de suppression, de modification et de vérification des informations sur l'utilisateur, tandis que le service de commande fournira la fonction d'ajout, de suppression, de modification et de vérification des informations de commande. Voici l'exemple de code pour le service utilisateur :

@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class UserServiceApplication {

    @Autowired
    private UserRepository userRepository;

    @GetMapping("/users")
    public List<User> getUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        return userRepository.save(user);
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }

    public static void main(String[] args) {
        SpringApplication.run(UserServiceApplication.class, args);
    }
}

Voici l'exemple de code pour le service de commande :

@SpringBootApplication
@EnableDiscoveryClient
@RestController
public class OrderServiceApplication {

    @Autowired
    private OrderRepository orderRepository;

    @GetMapping("/orders")
    public List<Order> getOrders() {
        return orderRepository.findAll();
    }

    @GetMapping("/orders/{id}")
    public Order getOrderById(@PathVariable Long id) {
        return orderRepository.findById(id).orElse(null);
    }

    @PostMapping("/orders")
    public Order createOrder(@RequestBody Order order) {
        return orderRepository.save(order);
    }

    @PutMapping("/orders/{id}")
    public Order updateOrder(@PathVariable Long id, @RequestBody Order order) {
        order.setId(id);
        return orderRepository.save(order);
    }

    @DeleteMapping("/orders/{id}")
    public void deleteOrder(@PathVariable Long id) {
        orderRepository.deleteById(id);
    }

    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

3) Enregistrez les microservices

Pour enregistrer les microservices sur le serveur Eureka, nous devons enregistrer les microservices dans la build fichier de chaque microservice Ajoutez les dépendances suivantes :

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

En même temps, nous devons ajouter l'annotation @EnableDiscoveryClient sur la classe de démarrage de chaque microservice pour activer la fonction d'enregistrement du service.

Après avoir déployé tous les microservices sur le cloud ou le serveur local, enregistrez-les sur le serveur Eureka, qui gérera ces microservices pour nous.

2. Réaliser l'équilibrage de charge

Dans un système de microservice réel, nous pouvons avoir plusieurs instances exécutant le même microservice pour améliorer l'évolutivité et la tolérance aux pannes du système. Cependant, nous avons besoin d'un moyen de décider quelle instance peut gérer les demandes des clients.

Spring Cloud propose deux méthodes pour réaliser l'équilibrage de charge : l'équilibrage de charge client et l'équilibrage de charge serveur. L'équilibrage de charge client fait référence à l'utilisation de l'algorithme d'équilibrage de charge pour sélectionner l'instance de microservice normale pour gérer la demande avant que le client ne lance la demande. L'équilibrage de charge côté serveur fait référence à la manière dont les requêtes sont réparties entre les instances de microservices. Chaque méthode a ses avantages et ses inconvénients, et la décision quant à la méthode à choisir doit être basée sur votre scénario d'application spécifique.

Dans cet article, nous implémenterons des microservices en utilisant l'équilibrage de charge côté client. Afin d'utiliser l'équilibrage de charge côté client, nous devons ajouter les dépendances suivantes dans chaque client :

<!-- Ribbon -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
</dependency>

Maintenant, nous pouvons annoter le RestTemplate avec l'annotation @LoadBalanced pour terminer automatiquement l'équilibrage de charge lorsqu'une demande est faite. Par exemple, nous pouvons utiliser le code suivant pour utiliser RestTemplate dans les services utilisateur :

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

3. Implémenter un disjoncteur de service et rétrograder

Dans une architecture de microservices, les appels entre microservices individuels généreront un grand nombre de requêtes réseau. S'il y a un problème avec l'un des microservices du système, l'ensemble du système peut être affecté. Pour résoudre ce problème, nous pouvons utiliser le composant Hystrix de Spring Cloud pour implémenter l'interruption et le déclassement du service.

Lorsqu'un problème survient dans un certain microservice, Hystrix empêchera l'effet d'avalanche grâce au mode disjoncteur. Le consommateur du service ne demandera plus le microservice et renverra une réponse par défaut. Dans le même temps, Hystrix peut également implémenter une fonction de dégradation lorsqu'un certain microservice est surchargé ou tombe en panne, il passe automatiquement à une implémentation alternative.

Par exemple, nous pouvons utiliser le code suivant pour implémenter Hystrix dans le service utilisateur :

<!-- Hystrix -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

<!-- Hystrix Dashboard -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
</dependency>

@EnableHystrix annotation pour activer la fonctionnalité Hystrix.

L'annotation @HystrixCommand activera le disjoncteur Hystrix dans la méthode getUserById :

@HystrixCommand(fallbackMethod = "defaultUser")
@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
    return restTemplate.getForObject("http://user-service/users/" + id, User.class);
}

public User defaultUser(Long id) {
    return new User();
}

4. Implémentation de la gestion de configuration distribuée

Spring Cloud Config est un outil pratique qui peut séparer la configuration entre les applications et les environnements. Stocker la configuration d'une application séparément dans un serveur de configuration et injecter la configuration de chaque application dans son environnement nous permet de configurer et de gérer rapidement plusieurs instances et environnements d'application.

Pour utiliser Spring Cloud Config, nous devons créer un serveur de configuration puis stocker la configuration de l'application dans le centre de configuration. Le serveur de configuration transmet ces configurations à l'application.

Ce qui suit est un exemple simple d'utilisation de Spring Cloud Config :

1) Créer un serveur de configuration

Pour créer un serveur de configuration, vous devez d'abord ajouter l'annotation @EnableConfigServer sur la classe de démarrage et spécifier le fichier de configuration référentiel :

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

在配置中心的存储库中可以存储多种类型的配置文件，包括.properties，.yml和.json等。配置可以根据应用程序和环境进行管理。例如，可以为生产环境存储prod.properties文件，而为测试环境存储test.properties文件。

2）将应用程序连接到配置服务器

要将应用程序连接到配置服务器，首先需要添加以下依赖项：

<!-- Config Client -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

然后，我们需要在应用程序的bootstrap.properties文件中指定配置服务器的位置：

spring.cloud.config.uri=http://localhost:8888

现在，当我们启动应用程序时，它将自动从配置服务器中获取配置。

5. 实现API网关

API网关是一个重要的组件，它充当了客户端和分布式后端系统之间的中间层。API网关可以用于路由请求，验证和授权请求，以及调用其他微服务。

Spring Cloud提供了Zuul组件来实现API网关。Zuul支持多种请求路由策略，如轮询，随机和会话保持等，并支持限流和动态路由等高级特性。

以下是如何将Zuul添加到应用程序中的简单示例：

1）添加依赖项

要将Zuul添加到应用程序中，需要添加以下依赖项：

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

2）创建Zuul代理

创建Zuul代理非常简单。我们只需要在启动类上添加@EnableZuulProxy注解，并且可以在配置文件中指定路由规则。例如，以下规则将路由到服务名称为user-service中的所有请求：

zuul:
  routes:
    users:
      path: /users/**
      serviceId: user-service

3）使用Zuul代理

现在，API网关应用程序已准备就绪。我们可以使用以下代码在应用程序中处理请求：

@RestController
public class ApiController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/users/{id}")
    public User getUserById(@PathVariable Long id) {
        return restTemplate.getForObject("http://api-gateway/user-service/users/" + id, User.class);
    }

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

以上是如何使用Spring Cloud搭建一个高性能的微服务集群的一些步骤和示例。当然，在实际项目中，还需要考虑更多的特性和问题，如服务注册与发现的高可用、分布式事务、服务治理、微服务监控和链路跟踪等。但希望这篇文章对您有所帮助！

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!