Erstellen Sie ein verteiltes und sicheres Spring Cloud-Microservice-Flugsystem

Mit der Entwicklung des Cloud Computing und der kontinuierlichen Ausweitung des Unternehmensgeschäfts hat sich die Microservice-Architektur zu einer sehr beliebten Systemarchitektur entwickelt. Unter ihnen sind Spring Boot und Spring Cloud derzeit die am häufigsten verwendeten Microservice-Frameworks. Spring Cloud bietet eine Fülle von Komponenten zur Unterstützung der Entwicklung und Verwaltung von Microservices, einschließlich Serviceregistrierung und -erkennung, Routing, Lastausgleich, Konfigurationsmanagement, Leistungsschalter usw.

In diesem Artikel werden wir als Beispiel ein verteiltes und sicheres Spring Cloud-Mikroservice-Flugsystem erstellen, um die leistungsstarken Funktionen von Spring Cloud zu demonstrieren.

1. Dienstregistrierung und -erkennung

Zuerst müssen wir Dienste registrieren und entdecken. Spring Cloud stellt Eureka bereit, um uns bei der Registrierung und Erkennung von Diensten zu unterstützen. Wir werden die Registrierung und Entdeckung von Diensten über Eureka Server abschließen.

Eureka Server-Anwendung erstellen:

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {

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

In application.properties konfigurieren:

server.port=8761

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

In den Dienstanbieter- und Dienstkonsumentenanwendungen müssen wir sie bei Eureka Server registrieren.

Konfiguriert in den application.properties des Dienstanbieters:

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

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

Konfiguriert in den application.properties des Dienstkonsumenten:

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

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

2. Kommunikation zwischen Diensten

Der Dienstanbieter erstellt eine RESTful-Schnittstelle über 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);
    }
}

Der Dienst Der Verbraucher ruft den Dienst über Spring RestTemplate auf:

@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);
    }
}

Unter anderem ist service.provider.url in den application.properties der Anwendung konfiguriert.

3. Lastausgleich

In tatsächlichen Anwendungen werden Dienstanbieter wahrscheinlich auf mehreren Instanzen bereitgestellt. Zu diesem Zeitpunkt müssen wir einen Lastausgleich durchführen, um die Leistung und Verfügbarkeit des Systems zu verbessern. Spring Cloud stellt Ribbon zur Unterstützung des Lastausgleichs bereit.

Konfigurieren Sie in den application.properties des Service-Consumers:

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

Verwenden Sie das lastverteilte RestTemplate in 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);
    }
}

Unter anderem wird service.provider.name in den application.properties der Anwendung konfiguriert.

4. Konfigurationsmanagement

Spring Cloud bietet Config zur einfachen Verwaltung der Anwendungskonfiguration. Wir können die Anwendungskonfiguration in einem Git-Repository speichern und über Config Server verteilen.

Config Server-Anwendung erstellen:

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {

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

In application.properties konfigurieren:

server.port=8888

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

Bei Dienstanbietern und Dienstkonsumenten können wir die Anwendungskonfiguration über Config Server erhalten.

Konfigurieren Sie in der application.yml des Dienstanbieters:

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

Konfigurieren Sie in der application.yml des Dienstkonsumenten:

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

5. Leistungsschalter

In einer Microservice-Architektur ist die Beziehung aufgrund der Abhängigkeiten zwischen Diensten sehr komplex und Einige Dienstausfälle oder Probleme können zum Zusammenbruch des gesamten Systems führen. Um mit dieser Situation umzugehen, können wir Leistungsschalter einsetzen, um Serviceeinbußen zu bewältigen.

Spring Cloud stellt Hystrix zur Unterstützung der Leistungsschalterfunktion bereit.

Konfigurieren Sie in application.yml des Dienstkonsumenten:

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

Fügen Sie die Annotation @HystrixCommand in FlightController hinzu:

@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);
    }
}

Unter diesen ist defaultGetFlight die Downgrade-Funktion.

6. Sicherheit

In verteilten Systemen sind Sicherheitsfragen sehr wichtig. Spring Cloud bietet Sicherheit zur Unterstützung des Sicherheitsmanagements.

Fügen Sie in der pom.xml der Service-Provider- und Service-Consumer-Anwendungen hinzu:

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

Konfigurieren Sie in der application.yml der Service-Provider- und Service-Consumer-Anwendungen:

security:
  basic:
    enabled: true

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

wobei Name und Passwort jeweils Benutzername und Passwort sind. Es ist zu beachten, dass in tatsächlichen Anwendungen sicherere Methoden zur Benutzerauthentifizierung und Berechtigungsverwaltung verwendet werden müssen.

Fügen Sie die Annotation @PreAuthorize auf der Klassenebene von FlightController hinzu:

@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);
        }
    }
}

Unter anderem wird die Annotation @PreAuthorize verwendet, um eine Sicherheitsüberprüfung auf FlightController durchzuführen. In tatsächlichen Anwendungen können für jede Methode unterschiedliche Sicherheitsüberprüfungen durchgeführt werden.

Auf diese Weise haben wir den Aufbau eines verteilten und sicheren Spring Cloud-Microservice-Flugsystems abgeschlossen. Anhand der Fälle in diesem Artikel können wir sehen, dass Spring Cloud eine Fülle von Komponenten bereitstellt, die uns beim Aufbau von Microservices unterstützen. Gleichzeitig müssen wir auch auf einige Herausforderungen achten, die die Microservice-Architektur mit sich bringt, wie z. B. Dienstregistrierung und -erkennung, Kommunikation zwischen Diensten, Lastausgleich, Konfigurationsmanagement, Leistungsschalter, Sicherheit und andere Probleme. In tatsächlichen Anwendungen müssen wir die Technologieauswahl und -konfiguration auf der Grundlage spezifischer Szenarien treffen.

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