Créer une passerelle API simple avec Spring Cloud Gateway-javaDidacticiel-php.cn

Dans les architectures de microservices modernes, une passerelle API est essentielle. Il fournit un point d'entrée unique pour plusieurs services, nous permettant de gérer le le routage, la sécurité, la limitation de débit, l'équilibrage de charge et bien plus encore. Dans cet article, nous explorerons comment configurer une passerelle API de base à l'aide de Spring Cloud Gateway et diriger les requêtes vers différents points de terminaison en fonction des chemins. Nous montrerons également comment utiliser des filtres pour manipuler les chemins de manière dynamique.

Plongeons dans le code !

Building a Simple API Gateway with Spring Cloud Gateway — Oh non !!

Conditions préalables

Pour suivre, vous aurez besoin de :

Java 11 ou supérieur
Spring Boot (3.0 ou version ultérieure recommandée)
Passerelle Cloud Spring réactive

Configuration du projet

Créez un nouveau projet Spring Boot et incluez la dépendance Spring Cloud Gateway. Vous pouvez le faire facilement en configurant un nouveau projet sur Spring Initializr, en sélectionnant Spring Boot et Reactive Spring Cloud Gateway sous dépendances.

Voici l'extrait pom.xml :

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

Copier après la connexion

Construire la passerelle API

Configurons notre passerelle pour gérer les demandes de trois chemins différents :

/get/country/{name} – Pour récupérer des détails sur un pays.
/get/langue/{name} – Pour obtenir des informations basées sur la langue.
/get/subregion/{name} – Pour récupérer des données pour des sous-régions spécifiques.

"Nous utiliserons l'API REST Countries pour simuler les autres microservices que nous avons dans notre architecture."

Configuration des itinéraires

J'ai créé un dossier appelé routeur à côté du fichier principal de l'application. À l'intérieur, nous allons créer un fichier appelé Routes.java dans lequel nous définissons nos itinéraires, configurons chaque chemin et appliquons des filtres aux requêtes directes dynamiques.

package dev.mspilari.api_gateway.router;

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Routes {

    @Bean
    public RouteLocator routeLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("country_route", p -> p
                        .path("/get/country/{name}")
                        .filters(f -> f.setPath("/v3.1/name/{name}"))
                        .uri("https://restcountries.com"))

                .route("language_route", p -> p
                        .path("/get/language/{name}")
                        .filters(f -> f.setPath("/v3.1/lang/{name}"))
                        .uri("https://restcountries.com"))

                .route("subregion_route", p -> p
                        .path("/get/subregion/{name}")
                        .filters(f -> f.setPath("/v3.1/subregion/{name}"))
                        .uri("https://restcountries.com"))
                .build();
    }
}

Copier après la connexion

Explication du Code

Définitions d'itinéraires : nous définissons chaque itinéraire à l'aide de la méthode route, qui prend un identifiant (par exemple, country_route) et un lambda qui définit le chemin.
Correspondance de chemin : .path("/get/country/{name}") est utilisé pour faire correspondre le modèle d'URL entrant. {name} est une variable qui peut être remplacée dynamiquement par n'importe quelle valeur, telle qu'un nom de pays comme « Brésil ».
Filtres : nous utilisons SetPath pour modifier le chemin de la requête sortante. Par exemple, .setPath("/v3.1/name/{name}") réécrit /get/country/{name} en /v3.1/name/{name}, le point de terminaison requis par l'API REST Countries.
URI : nous définissons l'uri sur https://restcountries.com, qui sert d'URL de base. Spring Cloud Gateway enverra le chemin modifié vers cet URI.

Exécution de la passerelle

Démarrez votre application Spring Boot. Vous pouvez désormais adresser des requêtes à la passerelle, qui les transmettra au bon point de terminaison.

Essayez les commandes suivantes dans votre terminal pour tester les itinéraires :

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-contract-stub-runner</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

Copier après la connexion

Chaque requête sera acheminée par la passerelle vers le point de terminaison de l'API des pays REST respectifs, en fonction du chemin et du paramètre.

Vérifier la réponse

Si tout est configuré correctement, vous devriez voir des réponses qui correspondent à ce que vous obtiendriez en appelant directement l'API REST Countries.

Par exemple :

package dev.mspilari.api_gateway.router;

import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class Routes {

    @Bean
    public RouteLocator routeLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("country_route", p -> p
                        .path("/get/country/{name}")
                        .filters(f -> f.setPath("/v3.1/name/{name}"))
                        .uri("https://restcountries.com"))

                .route("language_route", p -> p
                        .path("/get/language/{name}")
                        .filters(f -> f.setPath("/v3.1/lang/{name}"))
                        .uri("https://restcountries.com"))

                .route("subregion_route", p -> p
                        .path("/get/subregion/{name}")
                        .filters(f -> f.setPath("/v3.1/subregion/{name}"))
                        .uri("https://restcountries.com"))
                .build();
    }
}

Copier après la connexion

Avantages de l'utilisation de Spring Cloud Gateway

Point d'entrée unique : toutes les demandes transitent par la passerelle, simplifiant les interactions clients et la gestion des API.
Routage flexible : les itinéraires peuvent être facilement personnalisés avec des paramètres de chemin et des filtres.
Réécriture dynamique du chemin : La passerelle nous permet d'ajuster les chemins de requête de manière dynamique, ce qui facilite l'intégration avec des API externes sans modifier le code côté client.

Prochaines étapes

Cette configuration couvre les bases du routage avec Spring Cloud Gateway. Dans les prochains articles, nous explorerons des fonctionnalités supplémentaires, telles que :

Authentification et autorisation – sécurisez les itinéraires en intégrant OAuth ou JWT.
Limitation de débit et disjoncteurs – ajoutez de la résilience avec des filtres intégrés.
Équilibrage de charge – répartissez les requêtes sur plusieurs instances pour de meilleures performances.
Journalisation et observabilité – obtenez des informations sur le comportement et les performances des applications, et surveillez les modèles de trafic grâce au traçage distribué et à la journalisation centralisée.