[JAVA] Envoyez une demande au backend après une authentification unique avec Spring Cloud Gateway

Objectif

Pour divers outils de l'interface utilisateur Web tels que Locust qui peuvent être utilisés sans authentification de l'utilisateur Je voulais l'utiliser après avoir inséré ma propre authentification. J'ai trouvé difficile d'implémenter la fonction d'authentification dans chaque outil à mesure que les types d'outils augmentaient.

Par conséquent, placez l'application Spring Cloud Gateway devant chaque outil. Ici, nous acceptons toutes les demandes pour chaque outil, effectuons notre propre authentification et Si l'authentification est OK, j'ai essayé d'envoyer la demande à l'outil backend.

Configuration du projet

Ajoutez "Gateway" aux dépendances dans Spring initializr, créez un modèle et téléchargez-le.

Implémentation 1: tout d'abord, demandez la distribution sans authentification

Tout d'abord, sans la fonction d'authentification, acceptez simplement la demande avec Sprin Cloud Gateway, Essayons de distribuer la demande à l'outil backend.

Jusqu'à présent, il n'est pas nécessaire d'implémenter des classes Java, et cela peut être réalisé simplement en définissant application.yaml.

Cette fois, l'application Spring Cloud Gateway écoute sur le port 8080 et http://localhost:8080 Rendez-le accessible avec.

L'URL de l'outil d'interface utilisateur Web backend est http://localhost:9001 et http://localhost:9002 ça ira.

application.yaml

#Paramètres de numéro de port de Spring Cloud Gateway(Tu n'as pas à)
server:
  port: 8080

#Paramètres principaux de Spring Cloud Gateway
spring:
  cloud:
    gateway:
      routes:
        # -----------------------------------------------------
        # http://localhost:8080/tool1/hoge/fuga/...Demande
        # http://localhost:9001/hoge/fuga/...Flux vers
        # -----------------------------------------------------
        - id: tool1
          #Destination proxy
          uri: http://localhost:9001
          #routage
          predicates:
            - Path=/tool1/**
          #filtre(Insérer la réécriture de chemin et le traitement original)
          filters:
            - StripPrefix=1 #Coupez le début du chemin. Dans ce cas"/tool1"Se débarrasser de
        # -----------------------------------------------------
        # http://localhost:8080/tool2/hoge/fuga/...Demande
        # http://localhost:9002/hoge/fuga/...Flux vers
        # -----------------------------------------------------
        - id: tool2
          #Destination proxy
          uri: http://localhost:9002
          #routage
          predicates:
            - Path=/tool2/**
          #filtre(Insérer la réécriture de chemin et le traitement original)
          filters:
            - StripPrefix=1 #Coupez le début du chemin. Dans ce cas"/tool2"Se débarrasser de

L'important est spring.cloud.gateway.routes, et le contour de chaque élément est le suivant

Veuillez vous reporter au Document officiel de Spring Cloud Gateway pour découvrir quels sont les prédicats et filtres intégrés. Je pense.

Contrôle de fonctionnement

Au lieu de l'outil WebUI réel, lancez un serveur stub qui renvoie une chaîne fixe avec la commande nc.

$ (echo "HTTP/1.1 200 ok"; echo; echo "hello") | nc -l 9001

Envoyez ensuite une requête curl à Spring Cloud Gateway.

$ curl -v http://localhost:8080/tool1/hoge/fuga

Si les paramètres de Spring Cloud Gateway sont corrects, localhost: 8080 / tool1 / hoge / fuga request Il doit être transféré vers localhost: 9001 / hoge / fuga.

résultat

Le contenu de la demande envoyée au serveur stub est le suivant. Vous pouvez voir que le chemin de l'URL est / hoge / fuga au lieu de / tool / hoge / fuga.

$ (echo "HTTP/1.1 200 ok"; echo; echo "hello") | nc -l 9001
GET /hoge/fuga HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.64.1
Accept: */*
Forwarded: proto=http;host="localhost:8080";for="0:0:0:0:0:0:0:1:50024"
X-Forwarded-For: 0:0:0:0:0:0:0:1
X-Forwarded-Proto: http
X-Forwarded-Prefix: /tool1
X-Forwarded-Port: 8080
X-Forwarded-Host: localhost:8080
content-length: 0

Le résultat de la requête curl est le suivant Vous pouvez voir que Spring Cloud Gateway renvoie la réponse du serveur stub sur le back-end.

$ curl -v http://localhost:8080/tool1/hoge/fuga
> GET /tool1/hoge/fuga HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.64.1
> Accept: */*
>
< HTTP/1.1 200 OK
< transfer-encoding: chunked
<
hello

Implémentation 2: ajoutez votre propre filtre pour vous authentifier

Ensuite, créez votre propre filtre d'authentification et appliquez-le. Cette fois, extrayez la valeur de la clé "Authorization" de l'en-tête de la requête HTTP Si la valeur est "xxx", l'authentification est OK et une demande est envoyée au backend. Sinon, essayez de créer un filtre qui renvoie une réponse 401 Unauthorizaed comme authentification NG.

• Lors de la création d'une fonction d'authentification réelle, une logique aussi simple est NG, mais cette fois, pour des raisons d'explication, le code d'implémentation est écrit en simplifiant la logique d'authentification.

MyAuthFilter.java L'implémentation du filtre est la suivante et implémente une classe qui hérite de AbstractGatewayFilterFactory.

@Component
public class MyAuthFilter extends AbstractGatewayFilterFactory<MyAuthFilter.Config> {
    public MyAuthFilter() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            //Obtenir l'en-tête d'autorisation
            ServerHttpRequest request = exchange.getRequest();
            String authorizationHeader = Optional.ofNullable(request.getHeaders().get("Authorization"))
                    .map(h -> {return h.get(0);}).orElse("");

            //Si l'en-tête d'autorisation est xxx, la demande sera envoyée telle quelle avec une authentification réussie.
            //Sinon renvoie une réponse 401 non autorisée
            if(authorizationHeader.equals("xxx")) {
                return chain.filter(exchange.mutate().request(request).build());
            } else {
                ServerHttpResponse response = exchange.getResponse();
                response.setStatusCode(HttpStatus.UNAUTHORIZED);
                return response.setComplete();
            }
        };
    }

    public static class Config {

    }
}

application.yaml La création de votre propre classe de filtre comme décrit ci-dessus ne sera pas encore reflétée. Si vous souhaitez appliquer votre propre filtre, accédez à l'élément filtres dans application.yaml. J'écrirai le nom de classe de ce filtre unique.

L'image entière de application.yaml est la suivante, et seules les deux lignes qui disent "[Ajouter]" sont ajoutées.

#Paramètres principaux de Spring Cloud Gateway
spring:
  cloud:
    gateway:
      routes:
        # -----------------------------------------------------
        # http://localhost:8080/tool1/hoge/fuga/...Demande
        # http://localhost:9001/hoge/fuga/...Flux vers
        # -----------------------------------------------------
        - id: tool1
          #Destination proxy
          uri: http://localhost:9001
          #routage
          predicates:
            - Path=/tool1/**
          #filtre(Insérer la réécriture de chemin et le traitement original)
          filters:
            - MyAuthFilter  # [ajouter à]Insérez votre propre filtre d'authentification
            - StripPrefix=1 #Coupez le début du chemin. Dans ce cas"/tool1"Se débarrasser de
        # -----------------------------------------------------
        # http://localhost:8080/tool2/hoge/fuga/...Demande
        # http://localhost:9002/hoge/fuga/...Flux vers
        # -----------------------------------------------------
        - id: tool2
          #Destination proxy
          uri: http://localhost:9002
          #routage
          predicates:
            - Path=/tool2/**
          #filtre(Insérer la réécriture de chemin et le traitement original)
          filters:
            - MyAuthFilter  # [ajouter à]Insérez votre propre filtre d'authentification
            - StripPrefix=1 #Coupez le début du chemin. Dans ce cas"/tool2"Se débarrasser de

#Paramètres de numéro de port de Spring Cloud Gateway(Tu n'as pas à)
server:
  port: 8080

Contrôle de fonctionnement

Lancez le serveur stub sur le port 9001 comme précédemment, Demande sans en-tête d'autorisation comme ci-dessous Faites une demande curl avec un en-tête d'autorisation.

$ curl -v http://localhost:8080/tool1/hoge/fuga

$ curl -H 'Authorization: xxx' -v http://localhost:8080/tool1/hoge/fuga

résultat

Si vous demandez sans l'en-tête Authrozation, tel qu'implémenté dans MyAuthFilter, Une réponse 401 non autorisée est renvoyée.

$ curl -v http://localhost:8080/tool1/hoge/fuga
> GET /tool1/hoge/fuga HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.64.1
> Accept: */*
>
< HTTP/1.1 401 Unauthorized
< content-length: 0
<

Vous pouvez également voir qu'aucune demande n'est arrivée du côté du serveur de stub.

$ (echo "HTTP/1.1 200 ok"; echo; echo "hello") | nc -l 9001
* Pas de changement

Ensuite, lorsque vous demandez en définissant la valeur de xxx dans l'en-tête Authrozation, La chaîne hello retournée par le serveur stub est renvoyée.

$ curl -H 'Authorization: xxx' -v http://localhost:8080/tool1/hoge/fuga
> GET /tool1/hoge/fuga HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.64.1
> Accept: */*
> Authorization: xxx
>
< HTTP/1.1 200 OK
< transfer-encoding: chunked
<
hello

Vous pouvez voir que la demande arrive également du côté du serveur de stub.

$ (echo "HTTP/1.1 200 ok"; echo; echo "hello") | nc -l 9001
GET /hoge/fuga HTTP/1.1
Host: localhost:8080
User-Agent: curl/7.64.1
Accept: */*
Authorization: xxx
Forwarded: proto=http;host="localhost:8080";for="0:0:0:0:0:0:0:1:50517"
X-Forwarded-For: 0:0:0:0:0:0:0:1
X-Forwarded-Proto: http
X-Forwarded-Prefix: /tool1
X-Forwarded-Port: 8080
X-Forwarded-Host: localhost:8080
content-length: 0

Pour le moment, il semble que cela puisse être réalisé en jugeant si l'authentification est OK ou NG et en contrôlant s'il faut ou non envoyer une requête au back-end.

référence