Pratique de développement de capacités de microservices basée sur Spring Cloud

Avec le développement rapide du cloud computing et de la technologie du big data, les méthodes de conception architecturale et de développement des systèmes d'entreprise évoluent également constamment. L'architecture des microservices est l'un des changements importants. Il s'agit d'un modèle architectural qui divise une application unique en un ensemble de petits services qui coopèrent entre eux sur la base d'un mécanisme de communication léger, permettant ainsi d'obtenir des systèmes plus flexibles, évolutifs et maintenables. .

En tant que l'un des frameworks de microservices les plus populaires actuellement, Spring Cloud fournit un ensemble complet de solutions de développement de microservices, notamment la découverte, la configuration, la communication, l'équilibrage de charge, les disjoncteurs, les passerelles API, etc. Cet article présentera la pratique de développement de capacités de microservices basée sur Spring Cloud, ainsi que certains problèmes et solutions rencontrés dans la pratique.

1. Principes de base de l'architecture des microservices

L'architecture des microservices est un modèle architectural qui divise une seule application en un ensemble de petits services. Chaque service collabore entre eux sur la base d'un mécanisme de communication léger pour obtenir une solution plus flexible, évolutive et maintenable. système. Les principes de base de l'architecture des microservices comprennent :

1. Répartition des services : divisez une seule application en un ensemble de petits services en fonction des domaines d'activité ou des modules fonctionnels, et chaque service s'exécute et se met à niveau indépendamment.

2. Communication des services : les services collaborent entre eux sur la base de mécanismes de communication légers. Les méthodes de communication incluent l'API RESTful, la file d'attente de messages, le RPC, etc.

3. Découverte et enregistrement des services : gestion du cycle de vie des services, y compris l'enregistrement des services au centre d'enregistrement des services, la découverte des services et l'équilibrage de charge, etc.

4. Partitionnement des données : divisez les données en différents services via le partitionnement des données pour garantir l'isolation des données entre les services.

5. Exploitation et maintenance automatisées : réaliser le déploiement, la surveillance et la maintenance automatiques des services grâce à des outils automatisés, améliorant ainsi la fiabilité et la maintenabilité du système.

2. Spring Cloud Microservice Framework

Spring Cloud est un framework de microservices basé sur Spring Boot et fournit un ensemble complet de solutions de développement de microservices. Spring Cloud comprend les composants de base suivants :

1 Découverte et enregistrement du service : Eureka, Consul, Zookeeper, etc.

2. Équilibrage de charge client : Ruban.

3. Disjoncteur : Hystrix.

4. Passerelle de service : Zuul2.

5. Centre de configuration distribué : Spring Cloud Config.

6. Bus à messages : Spring Cloud Bus.

3. Pratique de développement de microservices Spring Cloud

Ce qui suit prend une application de microservice simple comme exemple pour présenter la pratique de développement de microservices basée sur Spring Cloud.

1. Créer un centre d'enregistrement Eureka

Tout d'abord, créez un centre d'enregistrement Eureka pour réaliser la découverte et l'enregistrement des services via Eureka.

Dans le projet Spring Boot, intégrez Eureka en ajoutant les dépendances suivantes :

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

Ajoutez l'annotation @EnableEurekaServer dans la classe de démarrage :

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

Après avoir démarré le centre d'enregistrement Eureka, vous pouvez accéder à http://localhost:8761 dans le navigateur Vous pouvez voir l'interface de gestion du centre d'inscription.

2. Créer un fournisseur de services

Créez un fournisseur de services simple qui fournit une interface hello pour renvoyer une chaîne.

Dans le projet Spring Boot, intégrez Eureka et Ribbon en ajoutant les dépendances suivantes :

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

Dans le fournisseur de services, activez le client Eureka en ajoutant l'annotation @EnableDiscoveryClient :

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

Créez un RestController pour fournir l'interface hello :

@RestController
public class HelloController {
   @RequestMapping("/hello")
   public String hello() {
      return "Hello World!";
   }
}

3. Créez un consommateur de service

Créez un consommateur de service, appelez l'interface fournie par le fournisseur de services et réalisez l'équilibrage de charge via Ribbon.

Dans le projet Spring Boot, intégrez Eureka et Ribbon en ajoutant les dépendances suivantes :

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

Dans le consommateur de services, activez le client Eureka en ajoutant l'annotation @EnableDiscoveryClient et activez l'équilibrage de charge du client Ribbon en ajoutant l'annotation @LoadBalanced :

@SpringBootApplication
@EnableDiscoveryClient
public class ServiceConsumerApplication {
   public static void main(String[] args) {
      SpringApplication.run(ServiceConsumerApplication.class, args);
   }
 
   @Bean
   @LoadBalanced
   public RestTemplate restTemplate() {
      return new RestTemplate();
   }
}

Créez un RestController pour appeler l'interface hello du fournisseur de services :

@RestController
public class HelloController {
   @Autowired
   private RestTemplate restTemplate;
 
   @RequestMapping("/hello")
   public String hello() {
      String url = "http://service-provider/hello";
      return restTemplate.getForObject(url, String.class);
   }
}

4 Créez une passerelle de service

Créez une passerelle de service pour exposer toutes les interfaces de microservices à l'extérieur et implémentez le transfert et le filtrage de routes via Zuul.

Dans le projet Spring Boot, intégrez Eureka et Zuul en ajoutant les dépendances suivantes :

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

Dans la passerelle de service, activez Zuul en ajoutant l'annotation @EnableZuulProxy :

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

Configurez les informations de routage de la passerelle, ajoutez ce qui suit dans application.yml Configuration :

zuul:
  routes:
    service-provider:
      path: /api/**
      serviceId: service-provider

5. Créer un centre de configuration

Créez un centre de configuration pour gérer la configuration via l'entrepôt Git afin d'obtenir une gestion centralisée et une actualisation dynamique de la configuration.

Dans le projet Spring Boot, intégrez le Config Server en ajoutant les dépendances suivantes :

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

Dans le centre de configuration, activez le centre de configuration en ajoutant l'annotation @EnableConfigServer :

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

Configurez les informations de l'entrepôt Git et lisez dans application.yml Règles :

spring:
  cloud:
    config:
      server:
        git:
          uri: git://http://gitlab.example.com/abc/config-repo.git
          search-paths: '{application}'
  profiles:
    active: native
  paths:
    config.path: /usr/local/config-repo

6. Implémenter le disjoncteur du service

Créer un disjoncteur pour gérer l'opération de dégradation lorsque le service est anormal ou défaillant.

Dans le projet Spring Boot, intégrez Hystrix en ajoutant les dépendances suivantes :

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

Dans le fournisseur de services, implémentez le disjoncteur en ajoutant l'annotation @HystrixCommand :

@RestController
public class HelloController {
   @RequestMapping("/hello")
   @HystrixCommand(fallbackMethod = "fallback")
   public String hello() {
      ...
   }
 
   public String fallback() {
      return "Fallback";
   }
}

7. Implémentez la surveillance des services

Créez un centre de surveillance, utilisé pour la surveillance et l'analyse des données des interfaces fournies par les microservices afin d'obtenir une surveillance en temps réel de l'état du service.

Dans le projet Spring Boot, intégrez Hystrix Dashboard et Turbine en ajoutant les dépendances suivantes :

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

在监控中心中，通过添加@EnableHystrixDashboard注解来启用Hystrix Dashboard：

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

在turbine服务提供者中，通过添加@EnableTurbine注解来启用Turbine：

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

在application.yml中配置Turbine的信息：

turbine:
  aggregator:
    clusterConfig: service-consumer
  appConfig: service-consumer,service-provider
  clusterNameExpression: new String("default")

四、总结

Spring Cloud是一套完备的微服务开发解决方案，通过其提供的一系列组件和架构设计原则，开发者可以轻松构建出高可用、高扩展和易维护的微服务应用。在实践中，我们发现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!