Créer un système de vol de microservices Spring Cloud distribué et sécurisé

Avec le développement du cloud computing et l'expansion continue des activités des entreprises, l'architecture des microservices est devenue une architecture système très populaire. Parmi eux, Spring Boot et Spring Cloud sont actuellement les frameworks de microservices les plus couramment utilisés. Spring Cloud fournit une multitude de composants pour prendre en charge le développement et la gestion de microservices, notamment l'enregistrement et la découverte de services, le routage, l'équilibrage de charge, la gestion de la configuration, les disjoncteurs, etc.

Dans cet article, nous allons construire un système volant de microservices Spring Cloud distribué et sécurisé comme exemple pour démontrer les fonctions puissantes de Spring Cloud.

1. Inscription et découverte des services

Tout d'abord, nous devons nous inscrire et découvrir les services. Spring Cloud fournit Eureka pour nous aider à réaliser l'enregistrement et la découverte des services. Nous terminerons l'enregistrement et la découverte des services via Eureka Server.

Créer une application Eureka Server :

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

Configurer dans application.properties :

server.port=8761

eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

Dans les applications de fournisseur de services et de consommateur de services, nous devons les enregistrer auprès d'Eureka Server.

Configuré dans l'application.properties du fournisseur de services :

spring.application.name=flight-service-provider
server.port=8080

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

Configuré dans l'application.properties du consommateur de services :

spring.application.name=flight-service-consumer
server.port=8081

eureka.client.service-url.defaultZone=http://localhost:8761/eureka/

2. Communication inter-services

Le fournisseur de services crée une interface RESTful via Spring MVC :

@RestController
@RequestMapping("/flights")
public class FlightController {

    @GetMapping("/{flightId}")
    public ResponseEntity<Flight> getFlight(@PathVariable Integer flightId) {
        Flight flight = new Flight(flightId, "Shanghai", "Beijing", new Date());
        return new ResponseEntity<>(flight, HttpStatus.OK);
    }
}

Le service Le consommateur appelle le service via Spring RestTemplate :

@Service
public class FlightService {

    @Autowired
    private RestTemplate restTemplate;

    @Value("${service.provider.url}")
    private String serviceProviderUrl;

    public Flight getFlight(Integer flightId) {
        return restTemplate.getForObject(serviceProviderUrl + "/flights/{flightId}", Flight.class, flightId);
    }
}

Parmi eux, service.provider.url est configuré dans le fichier application.properties de l'application.

3. Équilibrage de charge

Dans les applications réelles, les fournisseurs de services sont susceptibles d'être déployés sur plusieurs instances. À l'heure actuelle, nous devons effectuer un équilibrage de charge pour améliorer les performances et la disponibilité du système. Spring Cloud fournit un ruban pour prendre en charge l'équilibrage de charge.

Configurez dans le application.properties du consommateur de service :

service.provider.url=http://flight-service-provider/
spring.cloud.loadbalancer.ribbon.enabled=true

Utilisez le RestTemplate à charge équilibrée dans FlightService :

@Service
public class FlightService {

    @Autowired
    @LoadBalanced
    private RestTemplate restTemplate;

    @Value("${service.provider.name}")
    private String serviceProviderName;

    public Flight getFlight(Integer flightId) {
        return restTemplate.getForObject("http://" + serviceProviderName + "/flights/{flightId}", Flight.class, flightId);
    }
}

Parmi eux, service.provider.name est configuré dans le application.properties de l'application.

4. Gestion de la configuration

Spring Cloud fournit Config pour gérer facilement la configuration des applications. Nous pouvons stocker la configuration de l'application dans un référentiel Git et la distribuer via Config Server.

Créer une application Config Server :

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {

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

Configurer dans application.properties :

server.port=8888

spring.cloud.config.server.git.uri=https://github.com/xxx/xxx.git
spring.cloud.config.server.git.search-paths=config-repo

Chez les fournisseurs de services et les consommateurs de services, nous pouvons obtenir la configuration de l'application via Config Server.

Configurer dans l'application du fournisseur de services.yml :

spring:
  application:
    name: flight-service-provider
  cloud:
    config:
      uri: http://localhost:8888
      label: master
      profile: dev

Configurer dans l'application du consommateur de services.yml :

spring:
  application:
    name: flight-service-consumer
  cloud:
    config:
      uri: http://localhost:8888
      label: master
      profile: dev

5. Disjoncteur

Dans une architecture microservice, en raison des dépendances entre les services La relation est très complexe, et certains temps d'arrêt ou problèmes de service peuvent entraîner l'effondrement de l'ensemble du système. Pour faire face à cette situation, nous pouvons utiliser des disjoncteurs pour gérer la dégradation du service.

Spring Cloud fournit Hystrix pour prendre en charge la fonctionnalité de disjoncteur.

Configurez dans application.yml du consommateur de service :

spring:
  application:
    name: flight-service-consumer
  cloud:
    config:
      uri: http://localhost:8888
      label: master
      profile: dev
  loadbalancer:
    ribbon:
      enabled: true
  circuitbreaker:
    enabled: true
    resilience4j:
      enabled: false
      circuitBreaker:
        backend: flight-service-provider
        failureRateThreshold: 50

Ajoutez l'annotation @HystrixCommand dans FlightController :

@RestController
@RequestMapping("/flights")
public class FlightController {

    @Autowired
    private FlightService flightService;

    @GetMapping("/{flightId}")
    @HystrixCommand(fallbackMethod = "defaultGetFlight")
    public ResponseEntity<Flight> getFlight(@PathVariable Integer flightId) {
        Flight flight = flightService.getFlight(flightId);
        if (flight != null) {
            return new ResponseEntity<>(flight, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }

    public ResponseEntity<Flight> defaultGetFlight(Integer flightId) {
        return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
    }
}

Parmi eux, defaultGetFlight est la fonction de rétrogradation.

6. Sécurité

Dans les systèmes distribués, les questions de sécurité sont très importantes. Spring Cloud fournit une sécurité pour prendre en charge la gestion de la sécurité.

Ajoutez le pom.xml des applications du fournisseur de services et du consommateur de services :

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

Configurez dans le fichier application.yml des applications du fournisseur de services et du consommateur de services :

security:
  basic:
    enabled: true

spring:
  security:
    user:
      name: user
      password: password

où le nom et le mot de passe sont respectivement le nom et le mot de passe de l'utilisateur. Il convient de noter que dans les applications réelles, des méthodes plus sécurisées doivent être utilisées pour l'authentification des utilisateurs et la gestion des autorisations.

Ajoutez l'annotation @PreAuthorize au niveau de la classe de FlightController :

@RestController
@RequestMapping("/flights")
@PreAuthorize("hasRole('ROLE_ADMIN')")
public class FlightController {

    @Autowired
    private FlightService flightService;

    @GetMapping("/{flightId}")
    public ResponseEntity<Flight> getFlight(@PathVariable Integer flightId) {
        Flight flight = flightService.getFlight(flightId);
        if (flight != null) {
            return new ResponseEntity<>(flight, HttpStatus.OK);
        } else {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
    }
}

Parmi elles, l'annotation @PreAuthorize est utilisée pour effectuer une vérification de sécurité sur FlightController. Dans les applications réelles, différentes vérifications de sécurité peuvent être effectuées sur chaque méthode.

De cette manière, nous avons achevé la construction d'un système de vol de microservices Spring Cloud distribué et sécurisé. À travers les cas présentés dans cet article, nous pouvons voir que Spring Cloud fournit une multitude de composants pour nous aider à créer des microservices. Dans le même temps, nous devons également prêter attention à certains défis posés par l'architecture des microservices, tels que l'enregistrement et la découverte des services, la communication entre services, l'équilibrage de charge, la gestion de la configuration, les disjoncteurs, la sécurité et d'autres problèmes. Dans les applications réelles, nous devons sélectionner et configurer la technologie en fonction de scénarios spécifiques.

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!