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.
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/
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.
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.
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
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.
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!