Introduction aux principes et à l'utilisation de zuul dans SpringCloud

Cet article vous apporte une introduction aux principes et à l'utilisation de zuul dans Spring Cloud. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Introduction

Zuul est la porte d'entrée pour toutes les demandes provenant d'appareils et de sites Web vers le backend de votre application de streaming Netflix. En tant qu'application de services Edge, Zuul est conçu pour prendre en charge le routage dynamique, la surveillance, la résilience et la sécurité. Il peut également acheminer les demandes vers plusieurs groupes Amazon Autoscaling selon les besoins.

Zuul utilise une série de différents types de filtres, nous permettant d'appliquer rapidement et de manière flexible des fonctionnalités aux services Edge. Ces filtres nous aident à remplir les fonctions suivantes :

• Authentification et sécurité - Identifiez les exigences d'authentification pour chaque ressource et rejetez les demandes qui ne répondent pas à ces exigences.
• Insights et surveillance – Suivez les données et statistiques significatives en périphérie pour nous donner une vue précise de la production.
• Routage dynamique : acheminez dynamiquement les requêtes vers différents clusters backend selon les besoins.
• Test de stress – Augmentez progressivement le trafic vers le cluster pour évaluer les performances.
• Réduire la charge – allouez de la capacité à chaque type de demande et supprimez les demandes qui dépassent la limite.
• Gestion des réponses statiques - créez certaines réponses directement en périphérie au lieu de les transmettre au cluster interne
• Résilience multi-régions - acheminez les requêtes à travers les régions AWS pour diversifier l'utilisation de notre isation ELB et apporter nos atouts plus proches de nos membres

Comment ça marche

En vue de haut niveau, Zuul 2.0 est un serveur Netty qui exécute un pré-filtre (filtre entrant) et puis proxy la demande à l'aide du client Netty, puis renvoie la réponse après avoir exécuté le post-filtre (filtre sortant).

Les filtres sont au cœur de la logique métier de Zuul. Ils sont capables d'effectuer un très large éventail d'opérations et peuvent opérer dans différentes parties du cycle de vie requête-réponse, comme le montre le diagramme ci-dessus.

• Les filtres entrants sont exécutés avant le routage vers la source et peuvent être utilisés pour authentifier, acheminer et décorer les demandes.
• Les filtres Endpoint peuvent être utilisés pour renvoyer des réponses statiques, sinon le filtre ProxyEndpoint intégré acheminera la requête vers l'origine.
• Les filtres sortants sont exécutés après avoir obtenu la réponse de la source et peuvent être utilisés pour mesurer, décorer la réponse de l'utilisateur ou ajouter des en-têtes personnalisés.

Il existe également deux types de filtres : synchrone et asynchrone. Parce que nous fonctionnons sur une boucle d'événements, ne bloquez jamais le filtre. Si vous souhaitez bloquer, bloquez dans un filtre asynchrone, sur un pool de threads séparé - sinon utilisez un filtre synchrone.

Filtres utilitaires

• DebugRequest - Recherche un paramètre de requête pour ajouter des journaux de débogage supplémentaires à la requête
• Healthcheck - Simple statique filtre de point de terminaison qui renvoie 200 si tout a démarré correctement
• ZuulResponseFilter - ajoute des en-têtes d'informations pour fournir des détails supplémentaires sur l'itinéraire, l'exécution de la demande, l'état et la raison de l'erreur
• GZipResponseFilter - peut activer la réponse sortante gzip
• SurgicalDebugFilter - peut acheminer des requêtes spécifiques vers différents hôtes pour le débogage

Conseils d'utilisation

Dépendances :

    <dependency>
            <groupid>org.springframework.cloud</groupid>
            <artifactid>spring-cloud-starter-netflix-zuul</artifactid>
        </dependency>

Filtre MyFilter

@Component
public class MyFilter extends ZuulFilter {

    private static Logger log = LoggerFactory.getLogger(MyFilter.class);

    /**
     * pre：路由之前
     * routing：路由之时
     * post： 路由之后
     * error：发送错误调用
     * @return
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * 过滤的顺序
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;
    }

    /**
     * 这里可以写逻辑判断，是否要过滤，本文true,永远过滤
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }


    /**
     * 过滤器的具体逻辑。
     * 可用很复杂，包括查sql，nosql去判断该请求到底有没有权限访问。
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        log.info(String.format("%s >>> %s", request.getMethod(), request.getRequestURL().toString()));
        Object accessToken = request.getParameter("token");
        if(accessToken == null) {
            log.warn("token is empty");
            ctx.setSendZuulResponse(false);
            ctx.setResponseStatusCode(401);
            try {
                ctx.getResponse().getWriter().write("token is empty");
            }catch (Exception e){}

            return null;
        }
        log.info("ok");
        return null;
    }

}

Redirection de routage de configuration application.yml

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/
server:
  port: 8769
spring:
  application:
    name: cloud-service-zuul
zuul:
  routes:
    api-a:
      path: /api-a/**
      serviceId: cloud-service-ribbon
    api-b:
      path: /api-b/**
      serviceId: cloud-service-feign

Activer zuul

@SpringBootApplication
@EnableZuulProxy
@EnableEurekaClient
@EnableDiscoveryClient
public class CloudServiceZuulApplication {

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

}

Fusion de la route

/**
 * 路由熔断
 */
@Component
public class ProducerFallback implements FallbackProvider {
    private final Logger logger = LoggerFactory.getLogger(FallbackProvider.class);

    //指定要处理的 service。
    @Override
    public String getRoute() {
        return "spring-cloud-producer";
    }

    @Override
    public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
        if (cause != null && cause.getCause() != null) {
            String reason = cause.getCause().getMessage();
            logger.info("Excption {}",reason);
        }
        return fallbackResponse();
    }

    public ClientHttpResponse fallbackResponse() {
        return new ClientHttpResponse() {
            @Override
            public HttpStatus getStatusCode() throws IOException {
                return HttpStatus.OK;
            }

            @Override
            public int getRawStatusCode() throws IOException {
                return 200;
            }

            @Override
            public String getStatusText() throws IOException {
                return "OK";
            }

            @Override
            public void close() {

            }

            @Override
            public InputStream getBody() throws IOException {
                return new ByteArrayInputStream("The service is unavailable.".getBytes());
            }

            @Override
            public HttpHeaders getHeaders() {
                HttpHeaders headers = new HttpHeaders();
                headers.setContentType(MediaType.APPLICATION_JSON);
                return headers;
            }
        };
    }


}

Résumé

La passerelle Zuul dispose d'un mécanisme de transfert automatique, mais en fait Zuul a plus de scénarios d'application, tels que l'authentification , transfert de trafic, statistiques de requêtes, etc. Ces fonctions peuvent toutes être implémentées à l'aide de Zuul.

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!