Visão geral

Neste laboratório, você vai criar duas implantações de pods e vai trabalhar com três tipos de serviços, inclusive o recurso de Entrada, e vai ver como os serviços do Kubernetes no GKE estão associados aos balanceadores de carga de rede do Google Cloud.

Objetivos

O que você vai fazer neste laboratório:

• Ver o Kubernetes DNS em execução
• Definir vários tipos de serviço (ClusterIP, NodePort, LoadBalancer) nos manifestos, além de seletores de rótulo para se conectar a implantações e pods rotulados, implantá-los em um cluster e testar a conectividade
• Implantar um recurso de Entrada que conecte clientes a dois serviços diferentes com base no caminho de URL inserido
• Verificar a criação do balanceador de carga de rede do Google Cloud para os serviços type=LoadBalancer.

Configuração do laboratório

Acessar o Qwiklabs

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período e sem custos financeiros.

1. Faça login no Qwiklabs em uma janela anônima.

2. Confira o tempo de acesso do laboratório (por exemplo, 1:15:00) e finalize todas as atividades nesse prazo.
   Não é possível pausar o laboratório. Você pode reiniciar o desafio, mas vai precisar refazer todas as etapas.

3. Quando tudo estiver pronto, clique em Começar o laboratório.

4. Anote as credenciais (Nome de usuário e Senha). É com elas que você vai fazer login no Console do Google Cloud.

5. Clique em Abrir Console do Google.

6. Clique em Usar outra conta, depois copie e cole as credenciais deste laboratório nos locais indicados.
   Se você usar outras credenciais, vai receber mensagens de erro ou cobranças.

7. Aceite os termos e pule a página de recursos de recuperação.

Depois que você conclui as etapas iniciais de login, o painel do projeto é exibido.

Abrir o Cloud Shell

A maior parte deste laboratório vai ser feita no Cloud Shell.

1. Na barra de título do console do Google Cloud, clique em Ativar o Cloud Shell ( ).
2. Clique em Continuar.

Depois do provisionamento, o comando do Cloud Shell será exibido.

Tarefa 1: Conectar-se ao cluster do GKE do laboratório e testar o DNS

Nesta tarefa, você vai se conectar ao cluster do GKE do laboratório e criar um manifesto de implantação para um conjunto de pods no cluster que vai ser usado para testar a resolução de DNS do pod e nomes de serviços.

Conectar-se ao cluster do GKE do laboratório

1. No Cloud Shell, digite o comando abaixo para criar variáveis de ambiente da zona do Google Cloud e o nome do cluster que será usado para criar o cluster do laboratório:

export my_zone={{{project_0.default_zone | ZONE}}} export my_cluster=standard-cluster-1

2. Configure o preenchimento com tabulação da ferramenta de linha de comando kubectl:

source <(kubectl completion bash)

3. Configure o acesso ao cluster para o kubectl:

gcloud container clusters get-credentials $my_cluster --zone $my_zone

Tarefa 2: Criar pods e serviços para testar a resolução de DNS

Você vai criar um serviço chamado dns-demo com dois pods de aplicativo de amostra, dns-demo-1 e dns-demo-2.

Clone o repositório do arquivo de origem e implante os pods do aplicativo de amostra

Os pods que vão ser usados para testar a conectividade de rede pelos serviços do Kubernetes são implantados usando o arquivo de manifesto dns-demo.yaml que está disponível no repositório de origem. Você vai usar esses pods mais tarde para testar a conectividade por vários serviços de sistemas no seu cluster do Kubernetes.

Você também vai testar a conectividade de endereços externos usando o Cloud Shell. O Cloud Shell pode ser usado nesse caso, por ser uma rede completamente separada das redes de cluster do Kubernetes.

apiVersion: v1 kind: Service metadata: name: dns-demo spec: selector: name: dns-demo clusterIP: None ports: - name: dns-demo port: 1234 targetPort: 1234 --- apiVersion: v1 kind: Pod metadata: name: dns-demo-1 labels: name: dns-demo spec: hostname: dns-demo-1 subdomain: dns-demo containers: - name: nginx image: nginx --- apiVersion: v1 kind: Pod metadata: name: dns-demo-2 labels: name: dns-demo spec: hostname: dns-demo-2 subdomain: dns-demo containers: - name: nginx image: nginx

1. No Cloud Shell, digite o comando a seguir para clonar o repositório no Cloud Shell do laboratório:

git clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Crie um link flexível como atalho para o diretório de trabalho:

ln -s ~/training-data-analyst/courses/ak8s/v1.1 ~/ak8s

3. Mude para o diretório que contém os arquivos de exemplo deste laboratório:

cd ~/ak8s/GKE_Services/

4. Crie o serviço e os pods:

kubectl apply -f dns-demo.yaml

5. Verifique se seus pods estão em execução:

kubectl get pods

A saída vai ser semelhante a este exemplo.

Saída:

NAME READY STATUS RESTARTS AGE dns-demo-1 1/1 Running 0 8s dns-demo-2 1/1 Running 0 8s

Clique em Verificar meu progresso para ver o objetivo. Crie pods e serviços para testar a resolução de DNS

6. Para acessar o cluster, abra uma sessão interativa e execute o comando bash no dns-demo-1:

kubectl exec -it dns-demo-1 -- /bin/bash

Agora que você está dentro de um contêiner no cluster, os comandos subsequentes vão ser executados nesse contexto e você vai testar a conectividade de rede dando um ping em vários destinos nas próximas tarefas. No entanto, como você não tem uma ferramenta para dar um ping nesse contêiner, instale primeiro o comando ping.

7. Atualize o apt-get e instale uma ferramenta ping:

apt-get update apt-get install -y iputils-ping

8. Dê um ping no dns-demo-2:

ping dns-demo-2.dns-demo.default.svc.cluster.local

Esse ping deve funcionar e informar que o destino tem o endereço IP que você encontrou antes para o pod dns-demo-2.

9. Pressione Ctrl+C para cancelar o comando ping.
10. Dê um ping no FQDN do serviço de dns-demo, e não em um pod específico dentro do serviço:

ping dns-demo.default.svc.cluster.local

Esse ping também deve funcionar, mas vai retornar uma resposta do FQDN de um dos dois pods demo-dns. A resposta pode vir do pod demo-dns-1 ou demo-dns-2.

11. Pressione Ctrl+C para cancelar o comando ping.

O código do aplicativo implantado é executado dentro de um contêiner no cluster. Dessa forma, ele pode acessar outros serviços usando os FQDNs desses serviços de dentro do cluster. Essa abordagem é mais simples do que usar endereços IP ou até mesmo nomes de pod, porque eles têm mais chances de mudar.

12. Deixe o shell interativo no dns-demo-1 em execução.

Tarefa 3: Implantar uma carga de trabalho de amostra e um serviço ClusterIP

Nesta tarefa, você vai criar um manifesto de implantação para um conjunto de pods dentro do cluster e vai usar um serviço ClusterIP para expor os pods.

Implante um aplicativo da Web de amostra no cluster do Kubernetes Engine

Nesta tarefa, você vai implantar uma imagem do contêiner do aplicativo da Web de exemplo que escuta em um servidor HTTP, na porta 8080, usando o seguinte manifesto já criado no arquivo hello-v1.yaml

apiVersion: apps/v1 kind: Deployment metadata: name: hello-v1 spec: replicas: 3 selector: matchLabels: run: hello-v1 template: metadata: labels: run: hello-v1 name: hello-v1 spec: containers: - image: gcr.io/google-samples/hello-app:1.0 name: hello-v1 ports: - containerPort: 8080 protocol: TCP

1. Na barra de menus do Cloud Shell, clique no sinal de mais () para iniciar uma nova sessão.

Uma segunda sessão do Cloud Shell vai aparecer na janela. Clique nas sessões na barra de menus para alternar entre elas.

2. Na segunda guia do Cloud Shell, mude para o diretório que contém os arquivos de exemplo deste laboratório:

cd ~/ak8s/GKE_Services/

3. Para criar uma implantação do arquivo hello-v1.yaml, execute o seguinte comando:

kubectl create -f hello-v1.yaml

4. Para ver uma lista de implantações, execute o comando a seguir:

kubectl get deployments

A saída vai ser semelhante a este exemplo.

Saída:

NAME READY UP-TO-DATE AVAILABLE AGE hello-v1 3/3 3 3 14s

Defina os tipos de serviço no manifesto

Nesta tarefa, você vai implantar um Serviço usando um ClusterIP com o manifesto de amostra hello-svc.yaml já criado.

apiVersion: v1 kind: Service metadata: name: hello-svc spec: type: ClusterIP selector: name: hello-v1 ports: - protocol: TCP port: 80 targetPort: 8080

1. Para implantar o serviço ClusterIP, execute o seguinte comando:

kubectl apply -f ./hello-svc.yaml

Esse manifesto define um serviço ClusterIP e o aplica a pods que correspondem ao seletor. Nesse caso, o manifesto é aplicado aos pods hello-v1 que você implantou. Este serviço vai ser automaticamente aplicado a qualquer outra implantação com o rótulo name: hello-v1.

2. Verifique se o serviço foi criado e se um IP de cluster foi alocado:

kubectl get service hello-svc

É possível que seu endereço IP seja diferente da saída do exemplo.

Saída:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-svc ClusterIP 10.11.253.203 80/TCP 20s

Nenhum IP externo está alocado para este serviço. Como os endereços IP do cluster do Kubernetes não podem ser acessados externamente por padrão, criar esse serviço não faz com que o aplicativo seja acessado fora do cluster.

Clique em Verificar meu progresso para ver o objetivo. Implante uma carga de trabalho de amostra e um serviço ClusterIP

Teste o aplicativo

1. No Cloud Shell, tente abrir uma sessão HTTP para o novo serviço usando o seguinte comando:

curl hello-svc.default.svc.cluster.local

A conexão deve falhar porque esse serviço não está exposto fora do cluster.

Saída:

curl: (6) Could not resolve host: hello-svc.default.svc.cluster.local

Agora você vai testar o serviço dentro do cluster usando o shell interativo que está em execução no pod dns-demo-1.

2. Volte para a primeira janela do Cloud Shell, que está redirecionando stdin e stdout do pod dns-demo-1.
3. Instale curl para fazer chamadas para serviços da Web pela linha de comando:

apt-get install -y curl

4. Use o seguinte comando para testar a conexão HTTP entre os pods:

curl hello-svc.default.svc.cluster.local

Essa conexão precisa funcionar e apresentar uma resposta semelhante à saída mostrada abaixo. Seu nome de host talvez seja diferente da saída do exemplo.

Saída:

root@dns-demo-1:/# curl hello-svc.default.svc.cluster.local Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-mp4vd root@dns-demo-1:/#

Essa conexão funciona porque o clusterIP pode ser resolvido usando o DNS interno no cluster do Kubernetes Engine.

Tarefa 4: Converter o serviço atual em NodePort

Nesta tarefa, você vai converter o serviço ClusterIP atual em um serviço NodePort. Depois você vai testar novamente o acesso ao serviço dentro e fora do cluster.

Uma versão modificada do arquivo hello-svc.yaml, chamada hello-nodeport-svc.yaml, que altera o tipo de serviço para NodePort, já foi criada.

apiVersion: v1 kind: Service metadata: name: hello-svc spec: type: NodePort selector: name: hello-v1 ports: - protocol: TCP port: 80 targetPort: 8080 nodePort: 30100

1. Volte para a segunda janela do Cloud Shell. É a janela que NÃO está conectada a stdin e stdout do pod dns-test.
2. Para implantar o manifesto que altera o tipo de serviço de hello-svc para NodePort, execute o seguinte comando:

kubectl apply -f ./hello-nodeport-svc.yaml

Este manifesto redefine hello-svc como um serviço NodePort e atribui a porta de serviço 30100 em cada nó do cluster para esse serviço.

3. Digite o comando abaixo para verificar se o tipo de serviço foi alterado para NodePort:

kubectl get service hello-svc

É possível que seu endereço IP seja diferente da saída do exemplo.

Saída:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-svc NodePort 10.11.253.203 80:30100/TCP 59m Observação: ainda não há nenhum IP externo alocado para esse serviço.

Clique em Verificar meu progresso para ver o objetivo. Converta o serviço atual em NodePort

Teste o aplicativo

1. No Cloud Shell, tente abrir uma sessão HTTP para o novo serviço usando o seguinte comando:

curl hello-svc.default.svc.cluster.local

A conexão deve falhar porque esse serviço não está exposto fora do cluster.

Saída:

curl: (6) Could not resolve host: hello-svc.default.svc.cluster.local

Agora você vai testar o serviço de outro pod.

2. Volte para sua primeira janela do Cloud Shell, que atualmente está redirecionando stdin e stdout do pod dns-test.
3. Use o seguinte comando para testar a conexão HTTP entre os pods:

curl hello-svc.default.svc.cluster.local

Essa conexão precisa funcionar e apresentar uma resposta semelhante à saída mostrada abaixo. Seu nome de host talvez seja diferente da saída do exemplo.

Saída:

root@dns-demo-1:/# curl hello-svc.default.svc.cluster.local Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-mp4vd root@dns-demo-1:/#

Essa conexão funciona porque o clusterIP pode ser resolvido usando o DNS interno no cluster do GKE.

Tarefa 5: Criar endereços IP públicos estáticos usando a Rede do Google Cloud

Reserve endereços IP estáticos usando a rede do Google Cloud

1. No menu de navegação do console do Google Cloud, acesse Rede > Rede VPC > Endereços IP.

2. Clique em Reservar endereço IP estático externo.

3. Em Nome, digite regional-loadbalancer.

4. Examine as opções, mas não mude as configurações restantes. O tipo padrão é Regional.

Observação: a região padrão precisa corresponder à região em que você implantou o cluster do GKE. Se não corresponder, mude a região aqui. Se você aceitou os padrões do laboratório, a região é .

5. Clique em Reservar.

6. Anote o endereço IP externo chamado de regional-loadbalancer. Ele vai ser usado em uma tarefa posterior.

7. Clique em Reservar endereço IP estático externo.

8. Em Nome, digite global-ingress.

9. Mude o "Tipo" para Global.

10. Não altere as outras configurações padrão.

11. Clique em Reservar.

12. Anote o endereço IP externo, chamado de global-ingress. Ele vai ser usado em uma tarefa posterior.

Clique em Verificar meu progresso para ver o objetivo. Crie endereços IP públicos estáticos usando a rede do Google Cloud

Tarefa 6: Implantar um novo conjunto de pods e um serviço LoadBalancer

Agora você vai implantar um novo conjunto de pods executando outra versão do aplicativo para diferenciar com facilidade os dois serviços. Depois você vai fazer a exposição dos novos pods como um serviço LoadBalancer e acessar o serviço de fora do cluster.

Um segundo manifesto de implantação chamado hello-v2.yaml cria uma implantação que executa a versão 2 do aplicativo de amostra hello na porta 8080.

apiVersion: apps/v1 kind: Deployment metadata: name: hello-v2 spec: replicas: 3 selector: matchLabels: run: hello-v2 template: metadata: labels: run: hello-v2 name: hello-v2 spec: containers: - image: gcr.io/google-samples/hello-app:2.0 name: hello-v2 ports: - containerPort: 8080 protocol: TCP

1. Volte para a segunda janela do Cloud Shell. É a janela que NÃO está conectada a stdin e stdout do pod dns-test.
2. Para implantar o manifesto que cria a implantação hello-v2, execute o seguinte comando:

kubectl create -f hello-v2.yaml

3. Para ver uma lista de implantações, execute o comando a seguir:

kubectl get deployments

A saída vai ser semelhante a este exemplo.

Saída:

NAME READY UP-TO-DATE AVAILABLE AGE hello-v1 3/3 3 3 18m hello-v2 3/3 3 3 7s

Defina os tipos de serviço no manifesto

Nesta tarefa, você vai implantar um serviço LoadBalancer usando o manifesto de amostra hello-lb-svc.yaml que já foi criado.

Você vai usar o comando sed para substituir o endereço marcador 10.10.10.10 no arquivo yaml do balanceador de carga pelo endereço estático reservado para o balanceador de carga.

apiVersion: v1 kind: Service metadata: name: hello-lb-svc spec: type: LoadBalancer loadBalancerIP: 10.10.10.10 selector: name: hello-v2 ports: - protocol: TCP port: 80 targetPort: 8080

1. Verifique se você ainda está na segunda janela do Cloud Shell. É a janela que NÃO está conectada a stdin e stdout do pod dns-test.

2. Digite o comando a seguir no Cloud Shell para salvar o endereço IP estático regional criado anteriormente em uma variável de ambiente:

   export STATIC_LB=$(gcloud compute addresses describe regional-loadbalancer --region {{{project_0.default_region | REGION}}} --format json | jq -r '.address')

3. Digite o comando a seguir no Cloud Shell para substituir o endereço do marcador pelo endereço IP estático regional:

sed -i "s/10\.10\.10\.10/$STATIC_LB/g" hello-lb-svc.yaml

4. Para verificar se o endereço IP externo foi substituído corretamente, digite o comando a seguir no Cloud Shell:

cat hello-lb-svc.yaml

O loadBalancerIP deve corresponder ao endereço registrado anteriormente para o endereço IP estático reservado regional-loadbalancer.

5. Para implantar o manifesto do serviço LoadBalancer, execute o comando abaixo:

kubectl apply -f ./hello-lb-svc.yaml

Esse manifesto define um serviço LoadBalancer, que implanta um balanceador de carga de rede do Google Cloud para oferecer acesso externo ao serviço. Esse serviço é aplicado apenas a pods com o seletor name: hello-v2.

6. Verifique se o serviço foi criado e se uma porta do nó foi alocada:

kubectl get services

É possível que seu endereço IP seja diferente da saída do exemplo.

Saída:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE dns-demo ClusterIP None 1234/TCP 1h hello-lb-svc LoadBalancer 10.11.253.48 35.184.45.240 80:30103/TCP 2m hello-svc NodePort 10.11.253.203 80:30100/TCP 1h kubernetes ClusterIP 10.11.240.1 443/TCP 2h

Observe que o novo serviço LoadBalancer lista o endereço reservado regional-loadbalancer como o endereço IP externo. Em ambientes do GKE, o balanceador de carga externo para o tipo de serviço LoadBalancer é implementado usando um balanceador de carga do Google Cloud e vai levar alguns minutos para ser criado. Esse endereço IP externo torna o serviço acessível fora do cluster.

Confirme se o balanceador de carga regional do Google Cloud foi criado

1. No console do Google Cloud, acesse Rede > Serviços de rede > Balanceamento de carga.

Você vai ver um balanceador de carga TCP listado com um back-end de pool de destino e duas instâncias.

2. Clique no nome para abrir a página de detalhes.

Os detalhes devem mostrar que esse é um balanceador de carga TCP regional e usa o endereço IP estático que você chamou de regional-loadbalancer quando ele foi reservado.

Clique em Verificar meu progresso para ver o objetivo. Implante um novo conjunto de pods e um serviço LoadBalancer

Teste o aplicativo

1. No Cloud Shell, tente abrir uma sessão HTTP para o novo serviço usando o seguinte comando:

curl hello-lb-svc.default.svc.cluster.local

A conexão deve falhar porque esse nome de serviço não está exposto fora do cluster.

Saída:

curl: (6) Could not resolve host: hello-lb-svc.default.svc.cluster.local

Isso ocorre porque o endereço IP externo não está registrado com esse nome de host.

2. Tente a conexão novamente usando o endereço IP externo associado ao serviço balanceador de carga regional. Digite o comando abaixo e substitua [external_IP] pelo endereço IP externo do seu serviço:

curl [external_IP]

Exemplo:

curl 35.184.45.240

Dessa vez a conexão não falha, porque o endereço IP externo do LoadBalancer pode ser acessado fora do Google Cloud.

Observação: pode levar até cinco minutos para ficar disponível.

Saída:

Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d

3. Volte para a primeira janela do Cloud Shell, que está redirecionando stdin e stdout do pod dns-demo-1.
4. Use o seguinte comando para testar a conexão HTTP entre os pods:

curl hello-lb-svc.default.svc.cluster.local

Essa conexão precisa funcionar e apresentar uma resposta semelhante à saída mostrada abaixo. Seu nome de host vai ser diferente da saída do exemplo.

Saída:

root@dns-demo-1:/# curl hello-lb-svc.default.svc.cluster.local Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-78ggz root@dns-demo-1:/#

O nome do DNS interno funciona dentro do pod. Observe que você está acessando a mesma versão v2 do aplicativo como fez fora do cluster com o endereço IP externo.

5. Tente estabelecer a conexão novamente dentro do pod usando o endereço IP externo associado ao serviço. Digite o comando abaixo e substitua [external_IP] pelo endereço IP externo do seu serviço:

curl [external_IP]

Exemplo:

curl 35.184.45.240

Saída:

root@dns-demo-1:/# curl 35.184.45.240 Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d root@dns-demo-1:/#

O IP externo também funciona dentro dos pods em execução no cluster e retorna um resultado da mesma versão v2 dos aplicativos.

6. Saia da sessão de redirecionamento do console para o pod digitando:

exit

Você vai ser redirecionado de volta ao prompt de comando do Cloud Shell.

Tarefa 7: Implantar um recurso de entrada

Você tem dois serviços no cluster para o aplicativo hello: um hospeda a versão 1.0 com um serviço NodePort e o outro hospeda a versão 2.0 com um serviço LoadBalancer. Agora você vai implantar um recurso de Entrada que direciona o tráfego para os dois serviços com base no URL informado pelo usuário.

Crie um recurso Ingress

O Ingress é um recurso do Kubernetes que encapsula um conjunto de regras e configurações para encaminhar tráfego HTTP(S) externo aos serviços internos.

No GKE, a Entrada é implementada usando o Cloud Load Balancing. Quando você cria um recurso de Entrada no cluster, o GKE cria um balanceador de carga HTTP(S) e o configura para encaminhar o tráfego para seu aplicativo.

Um manifesto de amostra chamado hello-ingress.yaml, que configura um recurso de entrada, foi criado.

apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: hello-ingress annotations: nginx.ingress.kubernetes.io/rewrite-target: / kubernetes.io/ingress.global-static-ip-name: "global-ingress" spec: rules: - http: paths: - path: /v1 pathType: ImplementationSpecific backend: service: name: hello-svc port: number: 80 - path: /v2 pathType: ImplementationSpecific backend: service: name: hello-lb-svc port: number: 80

Esse arquivo de configuração define um recurso de entrada que vai ser anexado ao endereço IP estático global-ingress criado na etapa anterior. Esse recurso de entrada vai criar um balanceador de carga HTTP(S) global que vai direcionar tráfego aos seus serviços da Web com base no caminho inserido.

A anotação kubernetes.io/ingress.global-static-ip-name permite que você especifique um endereço IP reservado e com nome, que o recurso de Entrada vai usar ao criar para si mesmo o balanceador de carga HTTP(S) global do Google Cloud.

• Para implantar esse recurso de entrada, execute o seguinte comando:

kubectl apply -f hello-ingress.yaml

Depois que você implantar esse manifesto, o Kubernetes vai criar um recurso de Entrada no cluster. O controlador de entrada em execução no cluster é responsável pela criação de um balanceador de carga HTTP(S) para encaminhar todo o tráfego HTTP externo (na porta 80) aos serviços NodePort da Web e ao LoadBalancer que você expôs.

Confirme se um balanceador de carga HTTP(S) global foi criado

1. No console do Google Cloud, acesse Rede > Serviços de rede > Balanceamento de carga. Agora você deve ver também o balanceador de carga HTTP(S) listado.

2. Clique no nome para abrir a página de detalhes. Os detalhes devem mostrar que esse é um balanceador de carga HTTP(S) global e usa o endereço IP estático que você chamou de global-ingress quando ele foi reservado.

Clique em Verificar meu progresso para ver o objetivo. Implante um recurso de Entrada

Teste o aplicativo

1. Para descobrir o endereço IP externo do balanceador de carga relacionado ao seu aplicativo, execute o comando abaixo:

kubectl describe ingress hello-ingress

Saída parcial:

Name: hello-ingress Namespace: default Address: 35.244.173.44 Default backend: default-http-backend:80 (10.8.2.5:8080) Rules: Host Path Backends ---- ---- -------- * /v1 hello-svc:80 () /v2 hello-lb-svc:80 () [...] ingress.kubernetes.io/backends:{"k8s-[...]"HEALTHY"[...]} [...] Events: Type Reason Age From Message ---- ------ --- ---- ------- Normal ADD 5m loadbalancer-controller default/hello-ingress Normal CREATE 5m loadbalancer-controller ip: 35.244.173.44 Observação: aguarde alguns minutos para que o balanceador de carga seja ativado e as verificações de integridade sejam concluídas antes que o endereço externo seja exibido.

Repita o comando dentro de alguns minutos para verificar se o recurso de Entrada foi inicializado. Quando o balanceador de carga HTTP(S) global do Google Cloud for criado e inicializado, o comando vai informar o endereço IP externo que corresponde ao endereço IP estático global reservado anteriormente e chamado de global-ingress.

2. Use o endereço IP externo associado ao recurso de Entrada e digite o comando abaixo, substituindo [external_IP] pelo endereço IP externo do recurso de Entrada. Não se esqueça de incluir /v1 no caminho do URL:

curl http://[external_IP]/v1

Exemplo:

curl http://35.201.92.69/v1

Saída:

Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-4rmqw

O URL de v1 é configurado em hello-ingress.yaml para apontar para o serviço NodePort hello-svc, que direciona o tráfego para os pods do aplicativo v1:

Observação: o GKE pode levar alguns minutos para configurar as regras de encaminhamento até que o balanceador de carga Global usado para o recurso de Entrada esteja pronto para disponibilizar o aplicativo.

Enquanto isso, é possível que você receba erros, como HTTP 404 ou HTTP 500, até a configuração do balanceador de carga ser propagada em todo o mundo.

3. Agora teste o caminho do URL de v2 no Cloud Shell. Use o endereço IP externo associado ao recurso de Entrada e digite o comando abaixo, substituindo [external_IP] pelo endereço IP externo do recurso de Entrada. Não se esqueça de incluir /v2 no caminho do URL:

curl http://[external_IP]/v2

O URL de v2 é configurado no hello-ingress.yaml para apontar para o serviço LoadBalancer hello-lb-svc, que direciona o tráfego para os pods do aplicativo v2.

Exemplo:

curl http://35.201.92.69/v2

Saída:

Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d

Inspecione as alterações nos recursos de rede no console do Google Cloud

1. No console do Google Cloud, no menu de navegação, clique em Rede > Serviços de rede > Balanceamento de carga.

Há agora dois balanceadores de carga listados:

• O balanceador de carga regional inicial do serviço hello-lb-svc. Ele tem um nome no estilo UID e é configurado para balancear a carga do tráfego da porta TCP 80 para os nós do cluster.

• O segundo foi criado para o objeto de Entrada e é um balanceador de carga HTTP(S) completo que tem regras de host e caminho que correspondem à configuração da Entrada. O nome dele vai conter hello-ingress.

2. Clique no balanceador de carga que tem hello-ingress no nome.

Vão ser exibidas as informações de resumo dos protocolos, das portas, dos caminhos e dos serviços de back-end do balanceador de carga HTTP(S) global do Google Cloud criados para o recurso de Entrada.

Finalize o laboratório

Clique em Terminar o laboratório após a conclusão. O Google Cloud Ensina remove os recursos usados e limpa a conta por você.

Você vai poder avaliar sua experiência no laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Enviar.

O número de estrelas indica o seguinte:

• 1 estrela = muito insatisfeito
• 2 estrelas = insatisfeito
• 3 estrelas = neutro
• 4 estrelas = satisfeito
• 5 estrelas = muito satisfeito

Feche a caixa de diálogo se não quiser enviar feedback.

Para enviar seu feedback, fazer sugestões ou correções, use a guia Suporte.

Copyright 2020 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.