Esta implementação mostra como combinar o Cloud Service Mesh com o Cloud Load Balancing para expor aplicações numa malha de serviços a clientes da Internet.
Pode expor uma aplicação aos clientes de várias formas, consoante a localização do cliente. Esta implementação mostra como expor uma aplicação aos clientes combinando o Cloud Load Balancing com a malha de serviços do Google Cloud para integrar equilibradores de carga com uma malha de serviços. Esta implementação destina-se a profissionais avançados que executam o Cloud Service Mesh, mas também funciona para o Istio no Google Kubernetes Engine.
Arquitetura
O diagrama seguinte mostra como pode usar gateways de entrada de malha para integrar equilibradores de carga com uma malha de serviços:
Na topologia do diagrama anterior, a camada de entrada na nuvem, que é programada através do GKE Gateway, origina tráfego de fora da malha de serviços e direciona esse tráfego para a camada de entrada na malha. Em seguida, a camada de entrada da malha direciona o tráfego para os backends da aplicação alojados na malha.
A topologia anterior tem as seguintes considerações:
- Entrada na nuvem: nesta arquitetura de referência, configura o Google Cloud balanceador de carga através do GKE Gateway para verificar o estado dos proxies de entrada da malha nas respetivas portas de verificação de funcionamento expostas.
- Entrada de malha: na aplicação de malha, faz verificações de funcionamento nos back-ends diretamente para poder executar o equilíbrio de carga e a gestão de tráfego localmente.
O diagrama anterior ilustra a encriptação HTTPS do cliente para o balanceador de carga, do balanceador de carga para o proxy de entrada da malha e do proxy de entrada para o proxy sidecar. Google Cloud
Objetivos
- Implemente um cluster do Google Kubernetes Engine (GKE) no Google Cloud.
- Implemente uma malha de serviços na nuvem baseada no Istio no seu cluster do GKE.
- Configure o GKE Gateway para terminar o tráfego HTTPS público e direcionar esse tráfego para aplicações alojadas na malha de serviços.
- Implemente a aplicação Online Boutique no cluster do GKE que expõe aos clientes na Internet.
Otimização de custos
Neste documento, usa os seguintes componentes faturáveis do Google Cloud:
- Google Kubernetes Engine
- Compute Engine
- Cloud Load Balancing
- Certificate Manager
- Cloud Service Mesh
- Google Cloud Armor
- Cloud Endpoints
Para gerar uma estimativa de custos com base na sua utilização projetada,
use a calculadora de preços.
Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.
Antes de começar
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
-
Create a project: To create a project, you need the Project Creator
(
roles/resourcemanager.projectCreator), which contains theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
In the Google Cloud console, activate Cloud Shell.
Executa todos os comandos do terminal para esta implementação a partir do Cloud Shell.
Atualize para a versão mais recente da CLI do Google Cloud:
gcloud components updateDefina o seu Google Cloud projeto predefinido:
export PROJECT=PROJECT export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT} --format="value(projectNumber)") gcloud config set project ${PROJECT}Substitua
PROJECTpelo ID do projeto que quer usar para esta implementação.Crie um diretório de trabalho:
mkdir -p ${HOME}/edge-to-mesh cd ${HOME}/edge-to-mesh export WORKDIR=`pwd`Depois de concluir esta implementação, pode eliminar o diretório de trabalho.
No Cloud Shell, crie um novo ficheiro
kubeconfig. Este passo garante que não cria um conflito com o seu ficheirokubeconfig(predefinido) existente.touch edge2mesh_kubeconfig export KUBECONFIG=${WORKDIR}/edge2mesh_kubeconfigDefina variáveis de ambiente para o cluster do GKE:
export CLUSTER_NAME=edge-to-mesh export CLUSTER_LOCATION=us-central1Ative a API Google Kubernetes Engine:
gcloud services enable container.googleapis.comCrie um cluster do GKE Autopilot:
gcloud container --project ${PROJECT} clusters create-auto \ ${CLUSTER_NAME} --region ${CLUSTER_LOCATION} --release-channel rapidCertifique-se de que o cluster está em execução:
gcloud container clusters listO resultado é semelhante ao seguinte:
NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE NODE_VERSION NUM_NODES STATUS edge-to-mesh us-central1 1.27.3-gke.1700 34.122.84.52 e2-medium 1.27.3-gke.1700 3 RUNNING
No Cloud Shell, ative as APIs necessárias:
gcloud services enable mesh.googleapis.comAtive o Cloud Service Mesh na frota:
gcloud container fleet mesh enableRegiste o cluster na frota:
gcloud container fleet memberships register ${CLUSTER_NAME} \ --gke-cluster ${CLUSTER_LOCATION}/${CLUSTER_NAME}Aplique a etiqueta
mesh_idao clusteredge-to-mesh:gcloud container clusters update ${CLUSTER_NAME} --project ${PROJECT} --region ${CLUSTER_LOCATION} --update-labels mesh_id=proj-${PROJECT_NUMBER}Ativar a gestão automática do plano de controlo e o plano de dados gerido:
gcloud container fleet mesh update \ --management automatic \ --memberships ${CLUSTER_NAME}Após alguns minutos, verifique se o estado do plano de controlo é
ACTIVE:gcloud container fleet mesh describeO resultado é semelhante ao seguinte:
... membershipSpecs: projects/892585880385/locations/us-central1/memberships/edge-to-mesh: mesh: management: MANAGEMENT_AUTOMATIC membershipStates: projects/892585880385/locations/us-central1/memberships/edge-to-mesh: servicemesh: controlPlaneManagement: details: - code: REVISION_READY details: 'Ready: asm-managed-rapid' implementation: TRAFFIC_DIRECTOR state: ACTIVE dataPlaneManagement: details: - code: OK details: Service is running. state: ACTIVE state: code: OK description: 'Revision(s) ready for use: asm-managed-rapid.' updateTime: '2023-08-04T02:54:39.495937877Z' name: projects/e2m-doc-01/locations/global/features/servicemesh resourceState: state: ACTIVE ...No Cloud Shell, crie um namespace
ingress-gatewaydedicado:kubectl create namespace ingress-gatewayAdicione uma etiqueta de espaço de nomes ao espaço de nomes
ingress-gateway:kubectl label namespace ingress-gateway istio-injection=enabledO resultado é semelhante ao seguinte:
namespace/ingress-gateway labeled
Etiquetar o espaço de nomes
ingress-gatewaycomistio-injection=enabledindica ao Cloud Service Mesh para injetar automaticamente proxies sidecar do Envoy quando uma aplicação é implementada.Crie um certificado autoassinado usado pela gateway de entrada para terminar as ligações TLS entre o equilibrador de carga (a ser configurado mais tarde através do controlador da gateway do GKE) e a gateway de entrada, e armazene o certificado autoassinado como um segredo do Kubernetes: Google Cloud
openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 \ -subj "/CN=frontend.endpoints.${PROJECT}.cloud.goog/O=Edge2Mesh Inc" \ -keyout frontend.endpoints.${PROJECT}.cloud.goog.key \ -out frontend.endpoints.${PROJECT}.cloud.goog.crt kubectl -n ingress-gateway create secret tls edge2mesh-credential \ --key=frontend.endpoints.${PROJECT}.cloud.goog.key \ --cert=frontend.endpoints.${PROJECT}.cloud.goog.crtPara mais detalhes sobre os requisitos do certificado do gateway de entrada, consulte o guia de considerações sobre o protocolo de back-end seguro.
Execute os seguintes comandos para criar o YAML do recurso do gateway de entrada:
mkdir -p ${WORKDIR}/ingress-gateway/base cat <<EOF > ${WORKDIR}/ingress-gateway/base/kustomization.yaml resources: - github.com/GoogleCloudPlatform/anthos-service-mesh-samples/docs/ingress-gateway-asm-manifests/base EOF mkdir ${WORKDIR}/ingress-gateway/variant cat <<EOF > ${WORKDIR}/ingress-gateway/variant/role.yaml apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: name: asm-ingressgateway rules: - apiGroups: [""] resources: ["secrets"] verbs: ["get", "watch", "list"] EOF cat <<EOF > ${WORKDIR}/ingress-gateway/variant/rolebinding.yaml apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: asm-ingressgateway roleRef: apiGroup: rbac.authorization.k8s.io kind: Role name: asm-ingressgateway subjects: - kind: ServiceAccount name: asm-ingressgateway EOF cat <<EOF > ${WORKDIR}/ingress-gateway/variant/service-proto-type.yaml apiVersion: v1 kind: Service metadata: name: asm-ingressgateway spec: ports: - name: status-port port: 15021 protocol: TCP targetPort: 15021 - name: http port: 80 targetPort: 8080 - name: https port: 443 targetPort: 8443 appProtocol: HTTP2 type: ClusterIP EOF cat <<EOF > ${WORKDIR}/ingress-gateway/variant/gateway.yaml apiVersion: networking.istio.io/v1beta1 kind: Gateway metadata: name: asm-ingressgateway spec: servers: - port: number: 443 name: https protocol: HTTPS hosts: - "*" # IMPORTANT: Must use wildcard here when using SSL, as SNI isn't passed from GFE tls: mode: SIMPLE credentialName: edge2mesh-credential EOF cat <<EOF > ${WORKDIR}/ingress-gateway/variant/kustomization.yaml namespace: ingress-gateway resources: - ../base - role.yaml - rolebinding.yaml patches: - path: service-proto-type.yaml target: kind: Service - path: gateway.yaml target: kind: Gateway EOFAplique os CRDs da gateway de entrada:
kubectl apply -k ${WORKDIR}/ingress-gateway/variantCertifique-se de que todas as implementações estão em funcionamento:
kubectl wait --for=condition=available --timeout=600s deployment --all -n ingress-gatewayO resultado é semelhante ao seguinte:
deployment.apps/asm-ingressgateway condition met
No Cloud Shell, crie o ficheiro
HealthCheckPolicy.yaml:cat <<EOF >${WORKDIR}/ingress-gateway-healthcheck.yaml apiVersion: networking.gke.io/v1 kind: HealthCheckPolicy metadata: name: ingress-gateway-healthcheck namespace: ingress-gateway spec: default: checkIntervalSec: 20 timeoutSec: 5 #healthyThreshold: HEALTHY_THRESHOLD #unhealthyThreshold: UNHEALTHY_THRESHOLD logConfig: enabled: True config: type: HTTP httpHealthCheck: #portSpecification: USE_NAMED_PORT port: 15021 portName: status-port #host: HOST requestPath: /healthz/ready #response: RESPONSE #proxyHeader: PROXY_HEADER #requestPath: /healthz/ready #port: 15021 targetRef: group: "" kind: Service name: asm-ingressgateway EOFAplique o
HealthCheckPolicy:kubectl apply -f ${WORKDIR}/ingress-gateway-healthcheck.yamlNo Cloud Shell, crie uma política de segurança denominada
edge-fw-policy:gcloud compute security-policies create edge-fw-policy \ --description "Block XSS attacks"Crie uma regra de política de segurança que use os filtros XSS pré-configurados:
gcloud compute security-policies rules create 1000 \ --security-policy edge-fw-policy \ --expression "evaluatePreconfiguredExpr('xss-stable')" \ --action "deny-403" \ --description "XSS attack filtering"Crie o ficheiro
GCPBackendPolicy.yamlpara anexar ao serviço de gateway de entrada:cat <<EOF > ${WORKDIR}/cloud-armor-backendpolicy.yaml apiVersion: networking.gke.io/v1 kind: GCPBackendPolicy metadata: name: cloud-armor-backendpolicy namespace: ingress-gateway spec: default: securityPolicy: edge-fw-policy targetRef: group: "" kind: Service name: asm-ingressgateway EOFAplique o ficheiro
GCPBackendPolicy.yaml:kubectl apply -f ${WORKDIR}/cloud-armor-backendpolicy.yamlNo Cloud Shell, crie um endereço IP estático global para o Google Cloud balanceador de carga:
gcloud compute addresses create e2m-gclb-ip --globalEste endereço IP estático é usado pelo recurso GKE Gateway e permite que o endereço IP permaneça o mesmo, mesmo que o balanceador de carga externo seja alterado.
Obtenha o endereço IP estático:
export GCLB_IP=$(gcloud compute addresses describe e2m-gclb-ip \ --global --format "value(address)") echo ${GCLB_IP}Para criar um mapeamento estável e fácil de usar para o endereço IP estático do seu equilibrador de carga de aplicações, tem de ter um registo DNS público. Pode usar qualquer fornecedor DNS e automatização que quiser. Esta implementação usa pontos finais em vez de criar uma zona DNS gerida. O Endpoints fornece um registo de DNS gerido pela Google gratuito para um endereço IP público.
Execute o seguinte comando para criar o ficheiro de especificação YAML denominado
dns-spec.yaml:cat <<EOF > ${WORKDIR}/dns-spec.yaml swagger: "2.0" info: description: "Cloud Endpoints DNS" title: "Cloud Endpoints DNS" version: "1.0.0" paths: {} host: "frontend.endpoints.${PROJECT}.cloud.goog" x-google-endpoints: - name: "frontend.endpoints.${PROJECT}.cloud.goog" target: "${GCLB_IP}" EOFA especificação YAML define o registo DNS público no formato
frontend.endpoints.${PROJECT}.cloud.goog, em que${PROJECT}é o seu identificador exclusivo do projeto.Implemente o ficheiro
dns-spec.yamlno seu Google Cloud projeto:gcloud endpoints services deploy ${WORKDIR}/dns-spec.yamlO resultado é semelhante ao seguinte:
project [e2m-doc-01]... Operation "operations/acat.p2-892585880385-fb4a01ad-821d-4e22-bfa1-a0df6e0bf589" finished successfully. Service Configuration [2023-08-04r0] uploaded for service [frontend.endpoints.e2m-doc-01.cloud.goog]
Agora que o endereço IP e o DNS estão configurados, pode gerar um certificado público para proteger a parte frontal. Para fazer a integração com o GKE Gateway, usa certificados TLS do gestor de certificados.
No Cloud Shell, ative a API Certificate Manager:
gcloud services enable certificatemanager.googleapis.com --project=${PROJECT}Crie o certificado TLS:
gcloud --project=${PROJECT} certificate-manager certificates create edge2mesh-cert \ --domains="frontend.endpoints.${PROJECT}.cloud.goog"Crie o mapeamento de certificados:
gcloud --project=${PROJECT} certificate-manager maps create edge2mesh-cert-mapAnexe o certificado ao mapeamento de certificados com uma entrada de mapeamento de certificados:
gcloud --project=${PROJECT} certificate-manager maps entries create edge2mesh-cert-map-entry \ --map="edge2mesh-cert-map" \ --certificates="edge2mesh-cert" \ --hostname="frontend.endpoints.${PROJECT}.cloud.goog"No Cloud Shell, execute o seguinte comando para criar o
Gatewaymanifesto comogke-gateway.yaml:cat <<EOF > ${WORKDIR}/gke-gateway.yaml kind: Gateway apiVersion: gateway.networking.k8s.io/v1 metadata: name: external-http namespace: ingress-gateway annotations: networking.gke.io/certmap: edge2mesh-cert-map spec: gatewayClassName: gke-l7-global-external-managed # gke-l7-gxlb listeners: - name: http # list the port only so we can redirect any incoming http requests to https protocol: HTTP port: 80 - name: https protocol: HTTPS port: 443 addresses: - type: NamedAddress value: e2m-gclb-ip # reference the static IP created earlier EOFAplique o manifesto
Gatewaypara criar umGatewaydenominadoexternal-http:kubectl apply -f ${WORKDIR}/gke-gateway.yamlCrie o ficheiro
HTTPRoute.yamlpredefinido:cat << EOF > ${WORKDIR}/default-httproute.yaml apiVersion: gateway.networking.k8s.io/v1 kind: HTTPRoute metadata: name: default-httproute namespace: ingress-gateway spec: parentRefs: - name: external-http namespace: ingress-gateway sectionName: https rules: - matches: - path: value: / backendRefs: - name: asm-ingressgateway port: 443 EOFAplicar a predefinição
HTTPRoute:kubectl apply -f ${WORKDIR}/default-httproute.yamlCrie um ficheiro
HTTPRoute.yamladicional para fazer redirecionamentos de HTTP para HTTP(S):cat << EOF > ${WORKDIR}/default-httproute-redirect.yaml kind: HTTPRoute apiVersion: gateway.networking.k8s.io/v1 metadata: name: http-to-https-redirect-httproute namespace: ingress-gateway spec: parentRefs: - name: external-http namespace: ingress-gateway sectionName: http rules: - filters: - type: RequestRedirect requestRedirect: scheme: https statusCode: 301 EOFAplique o redirecionamento
HTTPRoute:kubectl apply -f ${WORKDIR}/default-httproute-redirect.yamlA conciliação demora tempo. Use o seguinte comando até
programmed=true:kubectl get gateway external-http -n ingress-gateway -wNo Cloud Shell, crie um namespace
onlineboutiquededicado:kubectl create namespace onlineboutiqueAdicione uma etiqueta ao espaço de nomes
onlineboutique:kubectl label namespace onlineboutique istio-injection=enabledEtiquetar o espaço de nomes
onlineboutiquecomistio-injection=enabledindica ao Cloud Service Mesh que injete automaticamente proxies sidecar do Envoy quando uma aplicação é implementada.Transfira os ficheiros YAML do Kubernetes para a app de exemplo Online Boutique:
curl -LO \ https://raw.githubusercontent.com/GoogleCloudPlatform/microservices-demo/main/release/kubernetes-manifests.yamlImplemente a app Online Boutique:
kubectl apply -f kubernetes-manifests.yaml -n onlineboutiqueO resultado é semelhante ao seguinte (incluindo avisos sobre a definição de pedidos e limites de recursos predefinidos do GKE Autopilot):
Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/emailservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources) deployment.apps/emailservice created service/emailservice created Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/checkoutservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources) deployment.apps/checkoutservice created service/checkoutservice created Warning: autopilot-default-resources-mutator:Autopilot updated Deployment onlineboutique/recommendationservice: adjusted resources to meet requirements for containers [server] (see http://g.co/gke/autopilot-resources) deployment.apps/recommendationservice created service/recommendationservice created ...Certifique-se de que todas as implementações estão em funcionamento:
kubectl get pods -n onlineboutiqueO resultado é semelhante ao seguinte:
NAME READY STATUS RESTARTS AGE adservice-64d8dbcf59-krrj9 2/2 Running 0 2m59s cartservice-6b77b89c9b-9qptn 2/2 Running 0 2m59s checkoutservice-7668b7fc99-5bnd9 2/2 Running 0 2m58s ...Aguarde alguns minutos para que o cluster do GKE Autopilot aprovisione a infraestrutura de computação necessária para suportar a aplicação.
Execute o seguinte comando para criar o manifesto
VirtualServicecomofrontend-virtualservice.yaml:cat <<EOF > frontend-virtualservice.yaml apiVersion: networking.istio.io/v1beta1 kind: VirtualService metadata: name: frontend-ingress namespace: onlineboutique spec: hosts: - "frontend.endpoints.${PROJECT}.cloud.goog" gateways: - ingress-gateway/asm-ingressgateway http: - route: - destination: host: frontend port: number: 80 EOFVirtualServiceé criado no espaço de nomes da aplicação (onlineboutique). Normalmente, o proprietário da aplicação decide e configura como e que tráfego é encaminhado para a aplicaçãofrontend, pelo queVirtualServiceé implementado pelo proprietário da app.Implemente
frontend-virtualservice.yamlno seu cluster:kubectl apply -f frontend-virtualservice.yamlAceda ao seguinte link:
echo "https://frontend.endpoints.${PROJECT}.cloud.goog"É apresentado o frontend da Online Boutique.
Para apresentar os detalhes do seu certificado, clique em Ver informações do site na barra de endereço do navegador e, de seguida, clique em Certificado (válido).
O visualizador de certificados apresenta detalhes do certificado gerido, incluindo a data de validade e quem emitiu o certificado.
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
No Cloud Shell, elimine os recursos
HTTPRoute:kubectl delete -f ${WORKDIR}/default-httproute-redirect.yaml kubectl delete -f ${WORKDIR}/default-httproute.yamlElimine o recurso do GKE Gateway:
kubectl delete -f ${WORKDIR}/gke-gateway.yamlElimine os recursos do certificado TLS (incluindo a entrada do mapa de certificados e o respetivo mapa de certificados principal):
gcloud --project=${PROJECT} certificate-manager maps entries delete edge2mesh-cert-map-entry --map="edge2mesh-cert-map" --quiet gcloud --project=${PROJECT} certificate-manager maps delete edge2mesh-cert-map --quiet gcloud --project=${PROJECT} certificate-manager certificates delete edge2mesh-cert --quietElimine a entrada de DNS dos pontos finais:
gcloud endpoints services delete "frontend.endpoints.${PROJECT}.cloud.goog"O resultado é semelhante ao seguinte:
Are you sure? This will set the service configuration to be deleted, along with all of the associated consumer information. Note: This does not immediately delete the service configuration or data and can be undone using the undelete command for 30 days. Only after 30 days will the service be purged from the system.
Quando lhe for pedido para continuar, introduza Y.
O resultado é semelhante ao seguinte:
Waiting for async operation operations/services.frontend.endpoints.edge2mesh.cloud.goog-5 to complete... Operation finished successfully. The following command can describe the Operation details: gcloud endpoints operations describe operations/services.frontend.endpoints.edge2mesh.cloud.goog-5
Elimine o endereço IP estático:
gcloud compute addresses delete ingress-ip --globalO resultado é semelhante ao seguinte:
The following global addresses will be deleted: - [ingress-ip]
Quando lhe for pedido para continuar, introduza Y.
O resultado é semelhante ao seguinte:
Deleted [https://www.googleapis.com/compute/v1/projects/edge2mesh/global/addresses/ingress-ip].
Elimine o cluster do GKE:
gcloud container clusters delete $CLUSTER_NAME --zone $CLUSTER_LOCATIONO resultado é semelhante ao seguinte:
The following clusters will be deleted. - [edge-to-mesh] in [us-central1]Quando lhe for pedido para continuar, introduza Y.
Após alguns minutos, o resultado é semelhante ao seguinte:
Deleting cluster edge-to-mesh...done. Deleted [https://container.googleapis.com/v1/projects/e2m-doc-01/zones/us-central1/clusters/edge-to-mesh].- Saiba mais sobre as funcionalidades oferecidas pelo GKE Ingress que pode usar com a sua malha de serviços.
- Saiba mais acerca dos diferentes tipos de balanceamento de carga na nuvem disponíveis para o GKE.
- Saiba mais sobre as funcionalidades oferecidas pela Cloud Service Mesh.
- Veja como implementar a entrada em vários clusters do GKE para o balanceamento de carga multirregional.
- Para ver mais arquiteturas de referência, diagramas e práticas recomendadas, explore o Centro de arquitetura na nuvem.
Crie clusters do GKE
As funcionalidades descritas nesta implementação requerem a versão 1.16 ou posterior do cluster do GKE.
Instale uma malha de serviço
Nesta secção, configura a malha de serviços na nuvem gerida com a API Fleet.
Implemente o GKE Gateway
Nos passos seguintes, implementa o Application Load Balancer externo através do controlador do GKE Gateway. O recurso GKE Gateway automatiza o aprovisionamento do balanceador de carga e a verificação de funcionamento do back-end. Além disso, usa o Certificate Manager para aprovisionar e gerir um certificado TLS e os Endpoints para aprovisionar automaticamente um nome DNS público para a aplicação.
Instale um gateway de entrada de malha de serviço
Como prática recomendada de segurança, recomendamos que implemente o gateway de entrada num espaço de nomes diferente do plano de controlo.
Aplique uma verificação de estado do gateway de entrada da malha de serviços
Ao integrar um gateway de entrada de malha de serviço num equilibrador de carga de aplicações, o equilibrador de carga de aplicações tem de ser configurado para fazer verificações de estado nos pods do gateway de entrada. Google Cloud O CRD HealthCheckPolicyfornece uma API para configurar essa verificação de funcionamento.
Defina políticas de segurança
O Cloud Armor oferece defesa contra DDoS e políticas de segurança personalizáveis que pode associar a um equilibrador de carga através de recursos de entrada. Nos passos seguintes, cria uma política de segurança que usa regras pré-configuradas para bloquear ataques de cross-site scripting (XSS). Esta regra ajuda a bloquear o tráfego que corresponde a assinaturas de ataques conhecidas, mas permite todo o outro tráfego. O seu ambiente pode usar regras diferentes consoante a sua carga de trabalho.
Configure o endereçamento IP e o DNS
Aprovisione um certificado TLS
Nesta secção, cria um certificado TLS através do gestor de certificados e associa-o a um mapa de certificados através de uma entrada do mapa de certificados. O balanceador de carga da aplicação, configurado através do GKE Gateway, usa o certificado para fornecer comunicações seguras entre o cliente e Google Cloud. Depois de criado, a entrada do mapa de certificados é referenciada pelo recurso do GKE Gateway.
Implemente os recursos do GKE Gateway e HTTPRoute
Nesta secção, configura o recurso GKE Gateway que aprovisiona o balanceador de carga de aplicações através do Google Cloud gke-l7-global-external-managedgatewayClass.
Além disso, configura recursos HTTPRoute que encaminham pedidos para a aplicação e fazem redirecionamentos de HTTP para HTTP(S).
Instale a app de amostra Online Boutique
Agora, tem um balanceador de carga HTTPS global que funciona como um front-end para a sua aplicação alojada na malha de serviço.
Limpar
Depois de concluir a implementação, pode limpar os recursos que criou na Google Cloud para não receber faturas relativas a estes no futuro. Pode eliminar o projeto na totalidade ou eliminar os recursos do cluster e, em seguida, eliminar o cluster.
Elimine o projeto
Elimine os recursos individuais
Se quiser manter o Google Cloud projeto que usou nesta implementação, elimine os recursos individuais: