Através do compartilhamento anterior, aprendemos sobre várias instalações principais da arquitetura de microsserviços, através desses componentes, podemos criar um sistema de arquitetura de microsserviço simples. Por exemplo, construa um Centro de Registro de Serviço Altamente disponível através do Spring Cloud Eureka e realize o registro e a descoberta de serviços;
Balanceamento de carga com fita de nuvem de primavera ou finge; Serviço Proteção tolerante a falhas com a Hystrix da nuvem de primavera para evitar a propagação de falhas. Depois que o microsserviço for construído, definitivamente forneceremos uma interface de serviço API RESTful unificada para o sistema externo para chamada.
Mas quando o sistema externo chama nossa API RESTful, como você determina qual serviço ele precisa para fornecer as funções específicas necessárias? Isso envolve a manutenção de regras de roteamento e listas de instâncias de serviço.
Isso apresenta nosso protagonista hoje - o Spring Cloud Zuul, que é um componente de gateway da API baseado na implementação da Netflix Zuul. Pode resolver dois grandes problemas:
Ok, vamos dar uma olhada em como implementar este serviço de gateway.
1. Construa um gateway e configure o roteamento
Aqui ainda precisamos usar os serviços anteriores de Hello-Service e Feign-Consumer. Costumávamos considerar o consumidor de Feign como um consumidor de serviço, mas não se esqueça que, no sistema Eureka, cada serviço é um provedor de serviços e um consumidor de serviço; portanto, o consumidor de Feign também é um provedor de serviços e interfaces como http: // localhost: 9001/Feign-Consumer são os serviços que fornecem.
Em seguida, construímos um serviço de gateway com a estrutura de código da seguinte maneira:
Etapas de implementação de código:
Crie uma nova Api-Gateway do Projeto Maven
Modificar o arquivo POM
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modelVersion> <voupId> com.sam </groupid> <TrAfactId> api-gateway </storkactid> <versão> 0.0.1-snapshot </versão> <PuerpId> org.springframework.boot </frugiD> <TRATIFACTID> Spring-boot-Starter-Parent </ArtifactId> <Versão> 1.5.1.release </sipers> </parentings> <! <GroupId> org.springframework.cloud </frupiD> <TRATIFACTID> Dependências de mola-cloud </ArtifactId> <Version> Camden.sr6 </versão </type> pom </type> <sCOPE> import </scope> </dependência> </dependency> </dependencement-gerenciamento> <Diens> <! Spring-Boot-Starter-Actuator/Spring-Boot-Starter-Hystrix/Spring-Boot-Starter-Ribbon-> <Ependency> <PuerpId> org.springframework.cloud </groupid> </Artifactid> Spring-Cloud-Starter-Zuul </Artifactid> </Dependência> </Dependências>
Crie uma nova aula de inicialização
/*** @enablezuulProxy Ative a função de serviço de gateway da API da Zuul**/@enablezuulProxy@springcloudappplicationpublic class gatewayapp {public static void main (string [] args) {springapplication.run (gatewayapp.class, args); }}Crie novo aplicativo.properties
server.port = 5555spring.application.name = API-Gateway#Adicionar à configuração das regras de roteamento#Configure através do zuul.Routes. <TaTa> é o nome da rota e pode ser especificado arbitrariamente, mas os nomes de rota de um conjunto de caminhos e URLs devem ser o mesmo#, conforme mostrado no exemplo a seguir: todos satisfazem/API-A/** Acesso às regras será roteado para o endereço de // LocalHost: 9001#, isto é, quando acessarmos htttp: // localHost: 55: 55: 55: Interface de microsserviço fornecida por http: // localhost: 9001/hello zuul.routes.api-a.path =/api-a/** zuul.routes.api-a.url = http: // localhost: 9001zuul.routes.api-b.path =/api-b/** zuul.routes.api-b.url = http: // localhost:
Teste, Start Eureka, Hello-Service, Feign-Consumer e o recém-adicionado serviço de Api-Gateway e, em seguida, visite http: // localhost: 5555/api-a/Feign-Consumer
Acessou com sucesso a interface de serviço do Feign-Consumer--Fign-Consumer.
As etapas acima implementam a configuração do roteamento tradicional. Essa configuração tem uma grande desvantagem, o que requer configuração manual de regras de roteamento no arquivo Application.Properties. Quando houver muitos serviços, a carga de trabalho de manutenção será muito grande. Para reduzir os custos de manutenção, há outra rota de rota - orientada a serviços.
2. Roteamento orientado a serviços
Spring Cloud Zuul e Eureka se integram, podemos fazer com que o caminho da rota não mapeie URLs específicos, mas serviços específicos, e os URLs de serviço são mantidos automaticamente pelo mecanismo de descoberta de serviços Eureka. Esse tipo de rota é a rota orientada ao serviço. A configuração de código específica é a seguinte:
Modificar arquivos POM e introduzir dependências Eureka
<!-Apresentando as dependências Eureka-> <Depence> <Puerpid> org.springframework.cloud </frugiD> <stifactId> Spring-cloud-starter-eureka
Modificar o arquivo de configuração do Application.Properties
server.port = 5555spring.application.name = api-gatewayzuul.routes.api-a.path =/api-a/**# Aqui usamos o serviço em vez de URL, e use o nome do serviço em vez do número da porta IP+ zuul.routes.api-a.serviceId = hello-serviceeureka.client.service-url.defaultZone = http: // localhost: 1111/eureka
Nota: Zuul.Routes.api-a.url = Hello-Service também pode implementar funções, mas não pode executar o balanceamento de carga normal e a proteção tolerante a falhas.
Teste, visite http: // localhost: 5555/api-a/hello
O acesso foi bem -sucedido.
3. Regras padrão para roteamento de serviço
Nas rotas orientadas para o serviço, como o nome <ToTer> é arbitrariamente, isso é possível:
zuul.routes.hello-service.path =/hello-service/** zuul.routes.hello-service.serviceId = hello-service
<Route> Nome é o nome do serviço. De fato, em aplicações reais, geralmente o nomeamos dessa maneira. Se houver tais regras, o Zuul poderá nos ajudar a implementar essas funções por padrão, economizando ainda mais o problema da configuração.
Vamos fazer um experimento e alterar o arquivo de configuração para:
server.port = 5555spring.application.name = api-gatewayeureka.client.service-url.defaultZone = http: // localhost: 1111/eureka
Em seguida, verificação de acesso à página
O acesso foi bem -sucedido.
No entanto, por padrão, os serviços em Eureka serão roteados pela Zuul, criando relacionamentos de mapeamento padrão, para que os serviços que não queremos ser abertos ao mundo exterior também sejam acessados externamente. No momento, podemos configurar regras que não exigem criação automática de roteamento por Zuul.Ignored Services. Quando Zuul.Ignored Services =*, todos os serviços não criam regras de roteamento automaticamente. No momento, a configuração de roteamento relevante precisa ser executada durante a configuração anterior.
=================== Linha dividida linda ===========================
Muito já foi dito antes, todos giram em torno de um problema: rotear regras e problemas de manutenção de instâncias de serviço. Então, como resolver o segundo problema (verificando o problema de redundância)?
4. Solicitar filtragem
Para verificar as solicitações do cliente no gateway da API, podemos usar filtros para interceptar e filtrar solicitações. O método de implementação é relativamente simples. Você só precisa herdar a classe abstrata Zuulfilter e implementar seus quatro métodos.
Modificar API-Gateway:
Classe de filtro adicionada
/*** herdando o zuulfilter e implementando suas 4 interfaces** para solicitar filtragem**/public class AccessFilter estende o zuulfilter {logger logger = loggerFactory.getLogger (acesshilter.class); / * * O Filter deve determinar se o filtro precisa ser executado * * retornar verdadeiro aqui, indicando que o filtro entrará em vigor em todas as solicitações. * No uso real, podemos usar esta função para especificar o intervalo efetivo do filtro*/ @Override public boolean devefilter () {return true; } /** Lógica específica do filtro** Aqui pedimos a Zuul para solicitar via ctx.setsendzuulResponse (false) e não o direcionamos*, definimos o código de erro retornado através do CTX.SetResponsestatuscode (401)** / @Override public Object Run ()xt) {request context =; HttpServletRequest request = context.getRequest (); Objeto AccessToken = request.getParameter ("AccessToken"); Logger.info ("Send {} request para {}", request.getMethod (), request.getRequesturl (). tostring ()); if (accessToken == null) {context.setsendzuulResponse (false); context.setResponsestatuscode (401); } retornar nulo; } /* FilterType Retorna o tipo de filtro* Ele determina em qual ciclo de vida o filtro é executado. Isso é definido como pré, o que significa que a solicitação será executada antes de ser roteada. * * PRE: FILTER ANTES DE PELASA APENASEIRA EXECUÇÃO * ROTA: Processe a solicitação e a rota * Post: Filtro executado após a conclusão do processamento da solicitação * Erro: Filtro executado quando ocorre um erro */ @Override public String filterType () {return "Pre"; } / * * O FilterOrder retorna a ordem de execução do filtro * * Quando a solicitação tiver vários filtros em um estágio, é necessário executá -lo uma vez com base no valor de retorno do método * * / @Override public Int Filterorder () {return 0; }}Modifique a aula de inicialização
/*** @enablezuulProxy Ative a função de serviço de gateway da API do Zuul**/ @enablezuulProxy @springcloudappplicationpublic class gatewayapp {// o bean é adicionado para implementar @bean public acessfilter acessfilter () {return accessFilter (); } public static void main (string [] args) {springapplication.run (gatewayapp.class, args); }}teste
) Visite http: // localhost: 5555/hello-service/hello, o acesso falhou
) Visite http: // localhost: 5555/hello-service/hello? AccessToken = Token, acesso normalmente
Estrutura de código modificado:
5. Expanda e estenda
De fato, quando a função de roteamento está realmente em execução, seu mapeamento de roteamento e encaminhamento de solicitação são todos feitos por vários filtros diferentes.
O mapeamento de roteamento é concluído principalmente por meio de filtros pré-tipo, que correspondem ao caminho da solicitação com as regras de roteamento configuradas e encontra o endereço de destino que precisa ser encaminhado.
A peça de encaminhamento de solicitação é concluída por um filtro de rota, que encaminha o endereço de rota obtido pelo filtro pré-tipo.
Portanto, pode -se dizer que os filtros são o componente mais central da função de gateway da API da Zuul. Cada solicitação HTTP que entra no Zuul será respondida através de uma série de cadeias de processamento de filtro e devolvida ao cliente.
Resumir
O exposto acima é o problema de usar o Zuul para implementar o serviço de gateway da API em Spring Cloud. Espero que seja útil para todos. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a todos a tempo. Muito obrigado pelo seu apoio ao site wulin.com!