Einführung in die Prinzipien und Verwendung von Zuul in SpringCloud

Dieser Artikel bietet Ihnen eine Einführung in die Prinzipien und die Verwendung von Zuul in Spring Cloud. Ich hoffe, dass er für Freunde hilfreich ist.

Einführung

Zuul ist die Eingangstür für alle Anfragen von Geräten und Websites an das Backend Ihrer Netflix-Streaming-Anwendung. Als Edge-Services-Anwendung ist Zuul darauf ausgelegt, dynamisches Routing, Überwachung, Ausfallsicherheit und Sicherheit zu unterstützen. Es kann bei Bedarf auch Anfragen an mehrere Amazon Autoscaling-Gruppen weiterleiten.

Zuul verwendet eine Reihe verschiedener Filtertypen, die es uns ermöglichen, Funktionen schnell und flexibel auf Edge-Dienste anzuwenden. Diese Filter helfen uns, die folgenden Funktionen auszuführen:

• Authentifizierung und Sicherheit – Identifizieren Sie die Authentifizierungsanforderungen für jede Ressource und lehnen Sie Anfragen ab, die diese Anforderungen nicht erfüllen.
• Einblicke und Überwachung – Verfolgen Sie aussagekräftige Daten und Statistiken am Edge, um uns einen genauen Überblick über die Produktion zu geben.
• Dynamisches Routing – leitet Anfragen je nach Bedarf dynamisch an verschiedene Backend-Cluster weiter.
• Stresstest – Erhöhen Sie den Datenverkehr zum Cluster schrittweise, um die Leistung zu bewerten.
• Last reduzieren – Weisen Sie jeder Art von Anfrage Kapazität zu und entfernen Sie Anfragen, die das Limit überschreiten.
• Statische Antwortverarbeitung – Erstellen Sie einige Antworten direkt am Edge, anstatt sie an den internen Cluster weiterzuleiten.
• Multiregionale Ausfallsicherheit – Leiten Sie Anfragen über AWS-Regionen hinweg weiter, um die Nutzung unserer ELB-Ismierung und -Bringung zu diversifizieren unsere Stärken näher an unsere Mitglieder heran

Wie es funktioniert

Auf hoher Ebene ist Zuul 2.0 ein Netty-Server, der einen Vorfilter (Eingehender Filter) ausführt und Stellen Sie dann die Anforderung mithilfe des Netty-Clients weiter und geben Sie die Antwort zurück, nachdem Sie den Post-Filter (Ausgangsfilter) ausgeführt haben.

Filter sind der Kern der Geschäftslogik von Zuul. Sie sind in der Lage, ein sehr breites Spektrum an Vorgängen durchzuführen und können in verschiedenen Teilen des Anforderungs-/Antwort-Lebenszyklus agieren, wie im Diagramm oben dargestellt.

• Eingehende Filter werden vor der Weiterleitung an die Quelle ausgeführt und können zur Authentifizierung, Weiterleitung und Dekoration von Anfragen verwendet werden.
• Endpunktfilter können verwendet werden, um statische Antworten zurückzugeben, andernfalls leitet der integrierte ProxyEndpoint-Filter die Anfrage an den Ursprung weiter.
• Ausgehende Filter werden ausgeführt, nachdem die Antwort von der Quelle erhalten wurde, und können zum Messen, Dekorieren der Benutzerantwort oder zum Hinzufügen benutzerdefinierter Header verwendet werden.

Es gibt auch zwei Arten von Filtern: synchrone und asynchrone. Da wir in einer Ereignisschleife laufen, blockieren Sie niemals den Filter. Wenn Sie blockieren möchten, blockieren Sie einen asynchronen Filter in einem separaten Threadpool. Andernfalls verwenden Sie einen synchronen Filter.

Utility-Filter

• DebugRequest – Findet einen Abfrageparameter, um der Anfrage zusätzliche Debug-Protokolle hinzuzufügen
• Healthcheck – Einfach statisch Endpunktfilter, der 200 zurückgibt, wenn alles korrekt gebootet wurde
• ZuulResponseFilter – fügt Informationsheader hinzu, um zusätzliche Details zu Route, Anforderungsausführung, Status und Fehlergrund bereitzustellen
• GZipResponseFilter – kann ausgehende gzip-Antworten aktivieren
• SurgicalDebugFilter – kann bestimmte Anfragen zum Debuggen an verschiedene Hosts weiterleiten

Verwendungstipps

Abhängigkeiten:

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

MeinFilter-Filter

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

}

application.yml-Konfigurations-Routing-Weiterleitung

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

Zuul aktivieren

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

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

}

Route Meltdown

/**
 * 路由熔断
 */
@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;
            }
        };
    }


}

Zusammenfassung

Das Zuul-Gateway verfügt über einen automatischen Weiterleitungsmechanismus, aber tatsächlich verfügt Zuul über mehr Anwendungsszenarien, wie zum Beispiel: Authentifizierung, Verkehrsweiterleitung, Anforderungsstatistiken usw. Diese Funktionen können alle mit Zuul implementiert werden.

Das obige ist der detaillierte Inhalt vonEinführung in die Prinzipien und Verwendung von Zuul in SpringCloud. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!