Neste documento, descrevemos como implantar a arquitetura de referência em Gerenciar e escalonar a rede de aplicativos Windows executados em Kubernetes gerenciados.
Estas instruções são destinadas a arquitetos de nuvem, administradores de rede e profissionais de TI responsáveis pelo design e gerenciamento de aplicativos do Windows executados em clusters do Google Kubernetes Engine (GKE).
Arquitetura
O diagrama a seguir mostra a arquitetura de referência que você usa ao implantar aplicativos do Windows executados em clusters do GKE gerenciados.
Conforme mostrado no diagrama anterior, uma seta representa o fluxo de trabalho para gerenciar a rede de aplicativos Windows executados no GKE usando gateways do Envoy e Cloud Service Mesh. O cluster regional do GKE inclui pools de nós do Windows e do Linux. O Cloud Service Mesh cria e gerencia rotas de tráfego para os pods do Windows.
Objetivos
- Crie e configure um cluster do GKE para executar aplicativos do Windows e proxies do Envoy.
- Implantar e verificar os aplicativos do Windows.
- Configure o Cloud Service Mesh como o plano de controle para os gateways do Envoy.
- Use a API Gateway do Kubernetes para provisionar o balanceador de carga de aplicativo interno e expor os gateways do Envoy.
- Entender as operações de implantação contínua que você criou.
Custos
A implantação dessa arquitetura usa os seguintes componentes faturáveis do Google Cloud:
Ao concluir a implantação, exclua os recursos criados para evitar a continuidade do faturamento. Para mais informações, consulte Limpar.
Antes de começar
-
No console do Google Cloud , na página do seletor de projetos, selecione ou crie um projeto do Google Cloud .
Papéis necessários para selecionar ou criar um projeto
- Selecionar um projeto: para selecionar um projeto, não é necessário ter um papel específico do IAM. É possível selecionar qualquer projeto em que você tenha um papel.
-
Criar um projeto: para criar um projeto, é preciso ter o papel de Criador de projetos
(
roles/resourcemanager.projectCreator), que contém a permissãoresourcemanager.projects.create. Saiba como conceder papéis.
-
Verifique se o faturamento está ativado para o projeto do Google Cloud .
-
Ative as APIs Cloud Shell e Cloud Service Mesh, se ainda não estiverem ativadas.
Funções necessárias para ativar APIs
Para ativar APIs, você precisa da permissão
serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de proprietário (roles/owner). Caso contrário, é possível conseguir essa permissão pelo papel de administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis. -
No console do Google Cloud , ative o Cloud Shell.
Se estiver executando em um ambiente de nuvem privada virtual (VPC) compartilhada, você também precisará seguir as instruções para criar manualmente a sub-rede somente proxy e a regra de firewall para as verificações de responsividade do Cloud Load Balancing.
Criar um cluster do GKE
Siga as etapas abaixo para criar um cluster do GKE. Use o cluster do GKE para conter e executar os aplicativos do Windows e os proxies do Envoy nessa implantação.
No Cloud Shell, execute o seguinte comando da Google Cloud CLI para criar um cluster regional do GKE com um nó em cada uma das três regiões:
gcloud container clusters create my-cluster --enable-ip-alias \ --num-nodes=1 \ --release-channel stable \ --enable-dataplane-v2 \ --region us-central1 \ --scopes=cloud-platform \ --gateway-api=standardAdicione o pool de nós do Windows ao cluster do GKE:
gcloud container node-pools create win-pool \ --cluster=my-cluster \ --image-type=windows_ltsc_containerd \ --no-enable-autoupgrade \ --region=us-central1 \ --num-nodes=1 \ --machine-type=n1-standard-2 \ --windows-os-version=ltsc2019Essa operação pode levar cerca de 20 minutos para ser concluída.
Armazene o ID do projeto do Google Cloud em uma variável de ambiente:
export PROJECT_ID=$(gcloud config get project)Conecte-se ao cluster do GKE:
gcloud container clusters get-credentials my-cluster --region us-central1Liste todos os nós no cluster do GKE:
kubectl get nodesA saída vai mostrar três nós do Linux e três nós do Windows.
Depois que o cluster do GKE estiver pronto, será possível implantar dois aplicativos de teste baseados no Windows.
Implantar dois aplicativos de teste
Nesta seção, você vai implantar dois aplicativos de teste baseados no Windows. Os dois aplicativos de teste mostram o nome do host em que o aplicativo é executado. Você também vai criar um serviço do Kubernetes para expor o aplicativo por meio de grupos de endpoints de rede (NEGs) independentes.
Quando você implanta um aplicativo baseado no Windows e um serviço do Kubernetes em um cluster regional, ele cria um NEG para cada zona em que o aplicativo é executado. Mais adiante, este guia de implantação discute como configurar esses NEGs como back-ends para serviços do Cloud Service Mesh.
No Cloud Shell, aplique o seguinte arquivo YAML com
kubectlpara implantar o primeiro aplicativo de teste. Esse comando implanta três instâncias do aplicativo de teste, uma em cada zona regional.apiVersion: apps/v1 kind: Deployment metadata: labels: app: win-webserver-1 name: win-webserver-1 spec: replicas: 3 selector: matchLabels: app: win-webserver-1 template: metadata: labels: app: win-webserver-1 name: win-webserver-1 spec: containers: - name: windowswebserver image: k8s.gcr.io/e2e-test-images/agnhost:2.36 command: ["/agnhost"] args: ["netexec", "--http-port", "80"] topologySpreadConstraints: - maxSkew: 1 topologyKey: kubernetes.io/hostname whenUnsatisfiable: DoNotSchedule labelSelector: matchLabels: app: win-webserver-1 nodeSelector: kubernetes.io/os: windowsAplique o serviço do Kubernetes correspondente e exponha-o com um NEG:
apiVersion: v1 kind: Service metadata: name: win-webserver-1 annotations: cloud.google.com/neg: '{"exposed_ports": {"80":{"name": "win-webserver-1"}}}' spec: type: ClusterIP selector: app: win-webserver-1 ports: - name: http protocol: TCP port: 80 targetPort: 80Verifique a implantação:
kubectl get podsA saída mostra que o aplicativo tem três pods do Windows em execução.
NAME READY STATUS RESTARTS AGE win-webserver-1-7bb4c57f6d-hnpgd 1/1 Running 0 5m58s win-webserver-1-7bb4c57f6d-rgqsb 1/1 Running 0 5m58s win-webserver-1-7bb4c57f6d-xp7ww 1/1 Running 0 5m58s
Verifique se o serviço do Kubernetes foi criado:
$ kubectl get svcA saída será assim:
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.64.0.1
443/TCP 58m win-webserver-1 ClusterIP 10.64.6.20 80/TCP 3m35s Execute o comando
describeparakubectlpara verificar se os NEGs correspondentes foram criados para o Serviço do Kubernetes em cada uma das zonas em que o aplicativo é executado:$ kubectl describe service win-webserver-1A saída será assim:
Name: win-webserver-1 Namespace: default Labels:
Annotations: cloud.google.com/neg: {"exposed_ports": {"80":{"name": "win-webserver-1"}}} cloud.google.com/neg-status: {"network_endpoint_groups":{"80":"win-webserver-1"},"zones":["us-central1-a","us-central1-b","us-central1-c"]} Selector: app=win-webserver-1 Type: ClusterIP IP Family Policy: SingleStack IP Families: IPv4 IP: 10.64.6.20 IPs: 10.64.6.20 Port: http 80/TCP TargetPort: 80/TCP Endpoints: 10.60.3.5:80,10.60.4.5:80,10.60.5.5:80 Session Affinity: None Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal Create 4m25s neg-controller Created NEG "win-webserver-1" for default/win-webserver-1-win-webserver-1-http/80-80-GCE_VM_IP_PORT-L7 in "us-central1-a". Normal Create 4m18s neg-controller Created NEG "win-webserver-1" for default/win-webserver-1-win-webserver-1-http/80-80-GCE_VM_IP_PORT-L7 in "us-central1-b". Normal Create 4m11s neg-controller Created NEG "win-webserver-1" for default/win-webserver-1-win-webserver-1-http/80-80-GCE_VM_IP_PORT-L7 in "us-central1-c". Normal Attach 4m9s neg-controller Attach 1 network endpoint(s) (NEG "win-webserver-1" in zone "us-central1-a") Normal Attach 4m8s neg-controller Attach 1 network endpoint(s) (NEG "win-webserver-1" in zone "us-central1-c") Normal Attach 4m8s neg-controller Attach 1 network endpoint(s) (NEG "win-webserver-1" in zone "us-central1-b") A saída do comando anterior mostra que um NEG foi criado para cada zona.
Opcional: use a CLI gcloud para verificar se os NEGs foram criados:
gcloud compute network-endpoint-groups listA resposta é a seguinte:
NAME LOCATION ENDPOINT_TYPE SIZE win-webserver-1 us-central1-a GCE_VM_IP_PORT 1 win-webserver-1 us-central1-b GCE_VM_IP_PORT 1 win-webserver-1 us-central1-c GCE_VM_IP_PORT 1
Para implantar o segundo aplicativo de teste, aplique o seguinte arquivo YAML:
apiVersion: apps/v1 kind: Deployment metadata: labels: app: win-webserver-2 name: win-webserver-2 spec: replicas: 3 selector: matchLabels: app: win-webserver-2 template: metadata: labels: app: win-webserver-2 name: win-webserver-2 spec: containers: - name: windowswebserver image: k8s.gcr.io/e2e-test-images/agnhost:2.36 command: ["/agnhost"] args: ["netexec", "--http-port", "80"] topologySpreadConstraints: - maxSkew: 1 topologyKey: kubernetes.io/hostname whenUnsatisfiable: DoNotSchedule labelSelector: matchLabels: app: win-webserver-2 nodeSelector: kubernetes.io/os: windowsCrie o serviço do Kubernetes correspondente:
apiVersion: v1 kind: Service metadata: name: win-webserver-2 annotations: cloud.google.com/neg: '{"exposed_ports": {"80":{"name": "win-webserver-2"}}}' spec: type: ClusterIP selector: app: win-webserver-2 ports: - name: http protocol: TCP port: 80 targetPort: 80Verifique a implantação do aplicativo:
kubectl get podsVerifique a saída e confirme se há três pods em execução.
Verifique se o serviço do Kubernetes e os três NEGs foram criados:
kubectl describe service win-webserver-2
Configurar o Cloud Service Mesh
Nesta seção, o Cloud Service Mesh é configurado como o plano de controle para os gateways do Envoy.
Mapeie os gateways do Envoy para a configuração de roteamento relevante do Cloud Service Mesh especificando o parâmetro scope_name. O parâmetro scope_name permite configurar diferentes regras de rota para os diferentes gateways do Envoy.
No Cloud Shell, crie uma regra de firewall que permita o tráfego de entrada dos serviços do Google que estão verificando a capacidade de resposta do aplicativo:
gcloud compute firewall-rules create allow-health-checks \ --network=default \ --direction=INGRESS \ --action=ALLOW \ --rules=tcp \ --source-ranges="35.191.0.0/16,130.211.0.0/22,209.85.152.0/22,209.85.204.0/22"Verifique a capacidade de resposta do primeiro aplicativo:
gcloud compute health-checks create http win-app-1-health-check \ --enable-logging \ --request-path="/healthz" \ --use-serving-portVerifique a capacidade de resposta do segundo aplicativo:
gcloud compute health-checks create http win-app-2-health-check \ --enable-logging \ --request-path="/healthz" \ --use-serving-portCrie um serviço de back-end do Cloud Service Mesh para o primeiro aplicativo:
gcloud compute backend-services create win-app-1-service \ --global \ --load-balancing-scheme=INTERNAL_SELF_MANAGED \ --port-name=http \ --health-checks win-app-1-health-checkCrie um serviço de back-end do Cloud Service Mesh para o segundo aplicativo:
gcloud compute backend-services create win-app-2-service \ --global \ --load-balancing-scheme=INTERNAL_SELF_MANAGED \ --port-name=http \ --health-checks win-app-2-health-checkAdicione os NEGs que você criou anteriormente. Esses NEGs estão associados ao primeiro aplicativo que você criou como back-end para o serviço de back-end do Cloud Service Mesh. Este exemplo de código adiciona um NEG para cada zona no cluster regional que você criou.
BACKEND_SERVICE=win-app-1-service APP1_NEG_NAME=win-webserver-1 MAX_RATE_PER_ENDPOINT=10 gcloud compute backend-services add-backend $BACKEND_SERVICE \ --global \ --network-endpoint-group $APP1_NEG_NAME \ --network-endpoint-group-zone us-central1-b \ --balancing-mode RATE \ --max-rate-per-endpoint $MAX_RATE_PER_ENDPOINT gcloud compute backend-services add-backend $BACKEND_SERVICE \ --global \ --network-endpoint-group $APP1_NEG_NAME \ --network-endpoint-group-zone us-central1-a \ --balancing-mode RATE \ --max-rate-per-endpoint $MAX_RATE_PER_ENDPOINT gcloud compute backend-services add-backend $BACKEND_SERVICE \ --global \ --network-endpoint-group $APP1_NEG_NAME \ --network-endpoint-group-zone us-central1-c \ --balancing-mode RATE \ --max-rate-per-endpoint $MAX_RATE_PER_ENDPOINTAdicione outros NEGs. Esses NEGs estão associados ao segundo aplicativo que você criou como back-end para o serviço de back-end do Cloud Service Mesh. Este exemplo de código adiciona um NEG para cada zona no cluster regional que você criou.
BACKEND_SERVICE=win-app-2-service APP2_NEG_NAME=win-webserver-2 gcloud compute backend-services add-backend $BACKEND_SERVICE \ --global \ --network-endpoint-group $APP2_NEG_NAME \ --network-endpoint-group-zone us-central1-b \ --balancing-mode RATE \ --max-rate-per-endpoint $MAX_RATE_PER_ENDPOINT gcloud compute backend-services add-backend $BACKEND_SERVICE \ --global \ --network-endpoint-group $APP2_NEG_NAME \ --network-endpoint-group-zone us-central1-a \ --balancing-mode RATE \ --max-rate-per-endpoint $MAX_RATE_PER_ENDPOINT gcloud compute backend-services add-backend $BACKEND_SERVICE \ --global \ --network-endpoint-group $APP2_NEG_NAME \ --network-endpoint-group-zone us-central1-c \ --balancing-mode RATE \ --max-rate-per-endpoint $MAX_RATE_PER_ENDPOINT
Configurar outros recursos do Cloud Service Mesh
Agora que você configurou os serviços do Cloud Service Mesh, é necessário configurar mais dois recursos para concluir a configuração do Cloud Service Mesh.
Primeiro, estas etapas mostram como configurar um recurso
Gateway. Um recurso Gateway é um recurso virtual usado para gerar regras de rota do Cloud Service Mesh. As regras de rota do Cloud Service Mesh são usadas para configurar proxies do Envoy como gateways.
Em seguida, as etapas mostram como configurar um recurso HTTPRoute para cada um dos serviços de back-end. O recurso HTTPRoute mapeia solicitações HTTP para o serviço de back-end relevante.
No Cloud Shell, crie um arquivo YAML chamado
gateway.yamlque defina o recursoGateway:cat <<EOF> gateway.yaml name: gateway80 scope: gateway-proxy ports: - 8080 type: OPEN_MESH EOFCrie o recurso
Gatewayinvocando o arquivogateway.yaml:gcloud network-services gateways import gateway80 \ --source=gateway.yaml \ --location=globalO nome de
Gatewayseráprojects/$PROJECT_ID/locations/global/gateways/gateway80.Use esse nome de
Gatewayao criarHTTPRoutespara cada serviço de back-end.
Crie o HTTPRoutes para cada serviço de back-end:
No Cloud Shell, armazene o ID do projeto do Google Cloud em uma variável de ambiente:
export PROJECT_ID=$(gcloud config get project)Crie o arquivo YAML
HTTPRoutepara o primeiro aplicativo:cat <<EOF> win-app-1-route.yaml name: win-app-1-http-route hostnames: - win-app-1 gateways: - projects/$PROJECT_ID/locations/global/gateways/gateway80 rules: - action: destinations: - serviceName: "projects/$PROJECT_ID/locations/global/backendServices/win-app-1-service" EOFCrie o recurso
HTTPRoutepara o primeiro aplicativo:gcloud network-services http-routes import win-app-1-http-route \ --source=win-app-1-route.yaml \ --location=globalCrie o arquivo YAML
HTTPRoutepara o segundo aplicativo:cat <<EOF> win-app-2-route.yaml name: win-app-2-http-route hostnames: - win-app-2 gateways: - projects/$PROJECT_ID/locations/global/gateways/gateway80 rules: - action: destinations: - serviceName: "projects/$PROJECT_ID/locations/global/backendServices/win-app-2-service" EOFCrie o recurso
HTTPRoutepara o segundo aplicativo:gcloud network-services http-routes import win-app-2-http-route \ --source=win-app-2-route.yaml \ --location=global
Implantar e expor os gateways do Envoy
Depois de criar os dois aplicativos de teste baseados no Windows e o Cloud Service Mesh, implante os gateways do Envoy criando um arquivo YAML de implantação. O arquivo YAML de implantação realiza as seguintes tarefas:
- Inicializa os gateways do Envoy.
- Configura os gateways do Envoy para usar o Cloud Service Mesh como plano de controle.
- Configura os gateways do Envoy para usar
HTTPRoutesno gateway chamadoGateway80.
Implante dois gateways de réplica do Envoy. Essa abordagem ajuda a tornar os gateways tolerantes a falhas e oferece redundância. Para escalonar automaticamente os gateways do Envoy com base na carga, é possível configurar um Autoescalonador Horizontal de Pods. Se você decidir configurar um Escalonador automático horizontal de pods, siga as instruções em Como configurar o escalonamento automático horizontal de pods.
No Cloud Shell, crie um arquivo YAML:
apiVersion: apps/v1 kind: Deployment metadata: creationTimestamp: null labels: app: td-envoy-gateway name: td-envoy-gateway spec: replicas: 2 selector: matchLabels: app: td-envoy-gateway template: metadata: creationTimestamp: null labels: app: td-envoy-gateway spec: containers: - name: envoy image: envoyproxy/envoy:v1.21.6 imagePullPolicy: Always resources: limits: cpu: "2" memory: 1Gi requests: cpu: 100m memory: 128Mi env: - name: ENVOY_UID value: "1337" volumeMounts: - mountPath: /etc/envoy name: envoy-bootstrap initContainers: - name: td-bootstrap-writer image: gcr.io/trafficdirector-prod/xds-client-bootstrap-generator imagePullPolicy: Always args: - --project_number='my_project_number' - --scope_name='gateway-proxy' - --envoy_port=8080 - --bootstrap_file_output_path=/var/lib/data/envoy.yaml - --traffic_director_url=trafficdirector.googleapis.com:443 - --expose_stats_port=15005 volumeMounts: - mountPath: /var/lib/data name: envoy-bootstrap volumes: - name: envoy-bootstrap emptyDir: {}Substitua my_project_number pelo número do projeto.
- Para encontrar o número do projeto, execute o comando a seguir:
gcloud projects describe $(gcloud config get project) --format="value(projectNumber)"
A porta
15005é usada para expor o endpoint do Envoy Admin chamado/stats. Ele também é usado para as seguintes finalidades:- Como um endpoint de responsividade do balanceador de carga de aplicativo interno.
- Como uma forma de consumir métricas do Google Cloud Managed Service para Prometheus do Envoy.
Quando os dois pods do Envoy Gateway estiverem em execução, crie um serviço do tipo
ClusterIPpara expô-los. Também é preciso criar um arquivo YAML chamadoBackendConfig.BackendConfigdefine uma verificação de responsividade não padrão. Essa verificação é usada para verificar a capacidade de resposta dos gateways do Envoy.Para criar a configuração de back-end com uma verificação de responsividade não padrão, crie um arquivo YAML chamado
envoy-backendconfig:apiVersion: cloud.google.com/v1 kind: BackendConfig metadata: name: envoy-backendconfig spec: healthCheck: checkIntervalSec: 5 timeoutSec: 5 healthyThreshold: 2 unhealthyThreshold: 3 type: HTTP requestPath: /stats port: 15005A verificação de capacidade de resposta vai usar o endpoint
/statsna porta15005para verificar continuamente a capacidade de resposta dos gateways do Envoy.Crie o serviço de gateways do Envoy:
apiVersion: v1 kind: Service metadata: name: td-envoy-gateway annotations: cloud.google.com/backend-config: '{"default": "envoy-backendconfig"}' spec: type: ClusterIP selector: app: td-envoy-gateway ports: - name: http protocol: TCP port: 8080 targetPort: 8080 - name: stats protocol: TCP port: 15005 targetPort: 15005Confira o serviço de gateways do Envoy que você criou:
kubectl get svc td-envoy-gateway
Criar o recurso de gateway do Kubernetes
A criação do recurso de gateway do Kubernetes provisiona o balanceador de carga de aplicativo interno para expor os gateways do Envoy.
Antes de criar esse recurso, você precisa criar dois certificados autoassinados de amostra e importá-los para o cluster do GKE como secrets do Kubernetes. Os certificados permitem a seguinte arquitetura de gateway:
- Cada aplicativo é veiculado por HTTPS.
- Cada aplicativo usa um certificado dedicado.
Ao usar certificados autogerenciados, o balanceador de carga de aplicativo interno pode usar até o limite máximo de certificados para expor aplicativos com diferentes nomes de domínio totalmente qualificados.
Para criar os certificados, use openssl.
No Cloud Shell, gere um arquivo de configuração para o primeiro certificado:
cat <<EOF >CONFIG_FILE [req] default_bits = 2048 req_extensions = extension_requirements distinguished_name = dn_requirements prompt = no [extension_requirements] basicConstraints = CA:FALSE keyUsage = nonRepudiation, digitalSignature, keyEncipherment subjectAltName = @sans_list [dn_requirements] 0.organizationName = example commonName = win-webserver-1.example.com [sans_list] DNS.1 = win-webserver-1.example.com EOFGere uma chave privada para o primeiro certificado:
openssl genrsa -out sample_private_key 2048Gere uma solicitação de certificado:
openssl req -new -key sample_private_key -out CSR_FILE -config CONFIG_FILEAssine e gere o primeiro certificado:
openssl x509 -req -signkey sample_private_key -in CSR_FILE -out sample.crt -extfile CONFIG_FILE -extensions extension_requirements -days 90Gere um arquivo de configuração para o segundo certificado:
cat <<EOF >CONFIG_FILE2 [req] default_bits = 2048 req_extensions = extension_requirements distinguished_name = dn_requirements prompt = no [extension_requirements] basicConstraints = CA:FALSE keyUsage = nonRepudiation, digitalSignature, keyEncipherment subjectAltName = @sans_list [dn_requirements] 0.organizationName = example commonName = win-webserver-2.example.com [sans_list] DNS.1 = win-webserver-2.example.com EOFGere uma chave privada para o segundo certificado:
openssl genrsa -out sample_private_key2 2048Gere uma solicitação de certificado:
openssl req -new -key sample_private_key2 -out CSR_FILE2 -config CONFIG_FILE2Assine e gere o segundo certificado:
openssl x509 -req -signkey sample_private_key2 -in CSR_FILE2 -out sample2.crt -extfile CONFIG_FILE2 -extensions extension_requirements -days 90
Importar certificados como secrets do Kubernetes
Nesta seção, você vai realizar as seguintes tarefas:
- Importe os certificados autoassinados para o cluster do GKE como secrets do Kubernetes.
- Crie um endereço IP estático para uma VPC interna.
- Crie o recurso da API Gateway do Kubernetes.
- Verifique se os certificados funcionam.
No Cloud Shell, importe o primeiro certificado como um Secret do Kubernetes:
kubectl create secret tls sample-cert --cert sample.crt --key sample_private_keyImporte o segundo certificado como um secret do Kubernetes:
kubectl create secret tls sample-cert-2 --cert sample2.crt --key sample_private_key2Para ativar o balanceador de carga de aplicativo interno, crie um endereço IP estático na VPC interna:
gcloud compute addresses create sample-ingress-ip --region us-central1 --subnet defaultCrie o arquivo YAML do recurso da API Gateway do Kubernetes:
kind: Gateway apiVersion: gateway.networking.k8s.io/v1beta1 metadata: name: internal-https spec: gatewayClassName: gke-l7-rilb addresses: - type: NamedAddress value: sample-ingress-ip listeners: - name: https protocol: HTTPS port: 443 tls: mode: Terminate certificateRefs: - name: sample-cert - name: sample-cert-2Por padrão, um gateway do Kubernetes não tem rotas padrão. O gateway retorna um erro de página não encontrada (404) quando as solicitações são enviadas para ele.
Configure um arquivo YAML
routepadrão para o gateway do Kubernetes que transmita todas as solicitações recebidas para os gateways do Envoy:kind: HTTPRoute apiVersion: gateway.networking.k8s.io/v1beta1 metadata: name: envoy-default-backend spec: parentRefs: - kind: Gateway name: internal-https rules: - backendRefs: - name: td-envoy-gateway port: 8080Verifique o fluxo completo enviando solicitações HTTP para os dois aplicativos. Para verificar se os gateways do Envoy roteiam o tráfego para os pods de aplicativo corretos, inspecione o cabeçalho do host HTTP.
Encontre e armazene o endereço IP do gateway do Kubernetes em uma variável de ambiente:
export EXTERNAL_IP=$(kubectl get gateway internal-https -o json | jq .status.addresses[0].value -r)Envie uma solicitação para o primeiro aplicativo:
curl --insecure -H "Host: win-app-1" https://$EXTERNAL_IP/hostNameEnvie uma solicitação para o segundo aplicativo:
curl --insecure -H "Host: win-app-2" https://$EXTERNAL_IP/hostNameVerifique se o nome do host retornado da solicitação corresponde aos pods que executam
win-app-1ewin-app-2:kubectl get podsA saída vai mostrar
win-app-1ewin-app-2.
Monitorar gateways do Envoy
Monitore seus gateways do Envoy com o Serviço gerenciado do Google Cloud para Prometheus.
Google Cloud Managed Service para Prometheus deve estar ativado por padrão no cluster que você criou anteriormente.
No Cloud Shell, crie um recurso
PodMonitoringaplicando o seguinte arquivo YAML:apiVersion: monitoring.googleapis.com/v1 kind: PodMonitoring metadata: name: prom-envoy spec: selector: matchLabels: app: td-envoy-gateway endpoints: - port: 15005 interval: 30s path: /stats/prometheusDepois de aplicar o arquivo YAML, o sistema começa a coletar métricas do Google Cloud Managed Service para Prometheus em um painel.
Para criar o painel de métricas do Google Cloud Managed Service para Prometheus, siga estas instruções:
- Faça login no console Google Cloud .
- Abra o menu .
- Clique em Operações > Monitoramento > Painéis.
Para importar o painel, siga estas instruções:
- Na tela "Painéis", clique em Biblioteca de amostra.
- Digite envoy na caixa de filtro.
- Clique em Visão geral do Istio Envoy Prometheus.
- Marque a caixa de seleção.
- Clique em Importar e em Confirmar para importar o painel.
Para visualizar o painel, siga estas instruções:
- Clique em Lista de painéis.
- Selecione Integrações.
- Clique em Visão geral do Istio Envoy Prometheus para ver o painel.
Agora você pode ver as métricas mais importantes dos seus gateways do Envoy. Também é possível configurar alertas com base nos seus critérios. Antes de fazer a limpeza, envie mais algumas solicitações de teste para os aplicativos e veja como o painel é atualizado com as métricas mais recentes.
Limpar
Para evitar cobranças na sua conta do Google Cloud pelos recursos usados na implantação, exclua o projeto ou mantenha o projeto e exclua cada um dos recursos.
Excluir o projeto
- No console Google Cloud , acesse a página Gerenciar recursos.
- Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
- Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.
A seguir
- Saiba mais sobre os produtos do Google Cloud usados neste guia de implantação:
- Para mais arquiteturas de referência, diagramas e práticas recomendadas, confira a Central de arquitetura do Cloud.
Colaboradores
Autor: Eitan Eibschutz | Consultor de soluções técnicas da equipe
Outros colaboradores:
- John Laham | Arquiteto de soluções
- Kaslin Fields | Mediadora de desenvolvedores
- Maridi (Raju) Makaraju | Líder de tecnologia de suporte
- Valavan Rajakumar | Arquiteto corporativo fundamental
- Victor Moreno | Gerente de produtos, Cloud Networking