Visão geral

Neste laboratório, você vai usar a linha de comando para criar clusters do GKE. Você vai inspecionar o arquivo kubeconfig e usar kubectl para manipular o cluster.

Objetivos

Neste laboratório, você vai aprender a fazer o seguinte:

• Usar kubectl para criar e manipular clusters do GKE
• Usar kubectl e os arquivos de configuração para implantar pods
• Usar o Container Registry para armazenar e implantar contêineres

Configuração do laboratório

Acesse 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.

Após concluir as etapas iniciais de login, o painel do projeto será exibido.

Abra o Cloud Shell

A maioria das tarefas vai ser realizada no Cloud Shell, um ambiente de linha de comando executado no Google Cloud. O Cloud Shell é uma máquina virtual baseada em Debian que contém todas as ferramentas de gestão necessárias (como docker, gcloud, gsutil e kubectl) e conta com um diretório principal permanente de 5 GB.

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

Após o provisionamento, o prompt do Cloud Shell será exibido:

Tarefa 1: implantar clusters do GKE

Nesta tarefa, você vai usar o Cloud Shell para implantar clusters do GKE.

1. No Cloud Shell, digite o comando a seguir para definir a variável de ambiente da zona e o nome do cluster:

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

2. No Cloud Shell, digite o seguinte comando para criar um cluster do Kubernetes:

gcloud container clusters create $my_cluster --num-nodes 3 --zone $my_zone --enable-ip-alias

Esse comando define a maioria das opções como padrão. Para acessar o conjunto completo de opções possíveis, consulte a referência do gcloud container clusters create.

Serão exibidos vários avisos sobre as mudanças nas configurações padrão do cluster do GKE, que foram introduzidas com a nova versão do Kubernetes adotada pelo GKE.

Observação: espere alguns minutos até que a implantação do cluster seja concluída.

Quando ela terminar, a página Kubernetes Engine > Clusters do console do Google Cloud terá a aparência da captura de tela.

Clique em Verificar meu progresso para conferir o objetivo. Implante clusters do GKE

Tarefa 2: Modificar os clusters do GKE

É fácil modificar vários parâmetros dos clusters no Console do Google Cloud ou no Cloud Shell. Nesta tarefa, você vai usar o Cloud Shell para mudar o número de nós em um cluster do GKE.

1. No Cloud Shell, execute o seguinte comando para que standard-cluster-1 passe a ter quatro nós:

gcloud container clusters resize $my_cluster --zone $my_zone --num-nodes=4 Observação: ao emitir comandos de cluster, geralmente é preciso especificar o nome e o local do cluster (região ou zona).

2. Quando a pergunta "Do you want to continue (y/n)" aparecer, pressione y para confirmar.

Nota: espere alguns minutos até que a implantação do cluster seja concluída.

Quando a operação terminar, você vai ver na página Kubernetes Engine > Clusters do Console do Google Cloud que o cluster agora tem quatro nós. É possível modificar vários outros parâmetros de cluster usando o comando gcloud container cluster.

Clique em Verificar meu progresso para conferir o objetivo. Modifique os clusters do GKE

Tarefa 3: Conectar-se a um cluster do GKE

Nesta tarefa, você vai usar o Cloud Shell para autenticar um cluster do GKE e depois vai inspecionar os arquivos de configuração do kubectl.

A autenticação no Kubernetes se aplica não só à comunicação entre o cluster e um cliente externo por meio do kube-APIserver em execução no mestre, mas também às interações internas e externas dos contêineres de cluster.

No Kubernetes, a autenticação pode assumir várias formas. No GKE, a autenticação geralmente é processada com tokens OAuth2 e pode ser gerenciada no projeto como um todo por meio do Cloud Identity and Access Management. Outra opção é usar o controle de acesso com base em papéis, que pode ser definido e configurado em cada cluster.

Os contêineres de cluster podem usar contas de serviço para autenticar e acessar recursos externos no GKE.

Observação: nas versões do Kubernetes anteriores à 1.12, os certificados de cliente e a autenticação básica não estão desativados por padrão. Como são métodos de autenticação menos seguros, eles precisam ser desativados para aumentar a segurança do cluster. Nas versões 1.12 e mais recentes, isso já é feito por padrão.

1. Execute o comando a seguir para criar um arquivo kubeconfig com as credenciais do usuário atual e permitir a autenticação. Ele também fornece os detalhes do endpoint de um cluster específico para permitir a comunicação com esse cluster na ferramenta de linha de comando kubectl.

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

Esse comando cria um diretório .kube no diretório principal, se ainda não houver um. No diretório .kube, o comando cria um arquivo chamado config (caso ainda não exista). Ele vai ser usado para armazenar as informações de autenticação e configuração. O arquivo de configuração é normalmente chamado kubeconfig.

2. Abra o arquivo kubeconfig com o editor de texto nano:

nano ~/.kube/config

Agora é possível examinar todos os dados de configuração de autenticação e endpoint armazenados no arquivo. Serão exibidas as informações do cluster que foram preenchidas durante a criação dele.

3. Pressione CTRL+X para sair do editor nano.

Observação: o arquivo kubeconfig pode conter informações de vários clusters. O contexto ativo atualmente (o cluster que os comandos kubectl manipulam) é indicado pela propriedade current-context.

Não é necessário executar o comando gcloud container clusters get-credentials para preencher o arquivo kubeconfig de clusters criados no mesmo contexto (mesmo usuário e ambiente), porque os detalhes desses clusters já foram preenchidos no momento da criação.

No entanto, é preciso executar o comando para se conectar aos clusters criados por outros usuários ou fora do ambiente. Ele também é uma forma fácil de mudar o contexto ativo para outro cluster.

Tarefa 4: Usar kubectl para inspecionar um cluster do GKE

Nesta tarefa, você vai usar o Cloud Shell e kubectl para inspecionar um cluster do GKE.

Depois de preencher o arquivo kubeconfig e definir o contexto ativo como um cluster específico, use a ferramenta de linha de comando kubectl para executar comandos no cluster. A maioria desses comandos aciona uma chamada da API REST diretamente no servidor da API mestre, que leva à ação associada.

1. No Cloud Shell, execute o seguinte comando para imprimir o conteúdo do arquivo kubeconfig:

kubectl config view

Os dados confidenciais do certificado são substituídos por DATA+OMITTED.

2. No Cloud Shell, execute o comando a seguir para imprimir as informações do cluster de contexto ativo:

kubectl cluster-info

A saída descreve o cluster de contexto ativo.

Saída:

Kubernetes master is running at https://104.155.191.14 GLBCDefaultBackend is running at https://104.155.191.14/api/v1/namespaces/kube-system/services/default-http-backend:http/proxy Heapster is running at https://104.155.191.14/api/v1/namespaces/kube-system/services/heapster/proxy KubeDNS is running at https://104.155.191.14/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy Metrics-server is running at https://104.155.191.14/api/v1/namespaces/kube-system/services/https:metrics-server:/proxy To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

3. No Cloud Shell, execute o seguinte comando para imprimir o contexto ativo:

kubectl config current-context

Uma linha de saída indica o cluster de contexto ativo.

Saída:

gke_[PROJECT_ID]_{{{project_0.default_zone | ZONE}}}_standard-cluster-1

PROJECT_ID é o ID do projeto. Essa informação é a mesma da propriedade current-context do arquivo kubeconfig.

4. No Cloud Shell, execute o seguinte comando para imprimir alguns detalhes de todos os contextos de cluster no arquivo kubeconfig:

kubectl config get-contexts

A saída tem várias linhas que dão detalhes do cluster criado e indicam qual é o cluster de contexto ativo. Em geral, esse comando lista algumas informações dos clusters presentes no arquivo kubeconfig do usuário, incluindo todos os clusters que já foram criados por ele e aqueles adicionados manualmente ao arquivo kubeconfig.

5. No Cloud Shell, execute o seguinte comando para alterar o contexto ativo:

kubectl config use-context gke_${GOOGLE_CLOUD_PROJECT}_{{{ project_0.default_zone | ZONE }}}_standard-cluster-1

Nesse caso, havia somente um cluster, então o comando não alterou nada.

No entanto, talvez você tenha mais de um cluster em um projeto futuramente. Use essa abordagem para mudar o contexto ativo quando seu arquivo kubeconfig tiver as credenciais e a configuração de vários clusters já preenchidas. É preciso ter o nome completo do cluster, o que inclui o prefixo gke, o ID do projeto, o local e o nome de exibição, todos concatenados com sublinhados.

6. No Cloud Shell, execute o seguinte comando para visualizar o uso de recursos nos nós do cluster:

kubectl top nodes

A saída será semelhante ao exemplo a seguir.

Saída:

NAME CPU(cores) CPU% MEMORY(bytes) MEMORY% gke-standard-cluster-1-def... 29m 3% 431Mi 16% gke-standard-cluster-1-def... 45m 4% 605Mi 22% gke-standard-cluster-1-def... 40m 4% 559Mi 21% gke-standard-cluster-1-def... 34m 3% 488Mi 18%

Outro comando top (kubectl top pods) mostra informações semelhantes em todos os pods implantados no cluster.

7. No Cloud Shell, execute o seguinte comando para ativar o preenchimento automático de bash no kubectl:

source <(kubectl completion bash)

Esse comando não produz saída.

8. No Cloud Shell, digite kubectl seguido por um espaço e pressione a tecla Tab duas vezes.

O shell exibe todos os comandos possíveis:

9. No Cloud Shell, digite kubectl co e pressione a tecla Tab duas vezes.

O shell exibe todos os comandos que começam com "co" (ou qualquer outra sequência de letras que você digitar).

Tarefa 5: Implantar pods em clusters do GKE

Nesta tarefa, você vai usar o Cloud Shell para implantar pods em clusters do GKE.

Use kubectl para implantar pods no GKE

O Kubernetes usa a abstração de um pod para agrupar um ou mais contêineres relacionados como uma só entidade a ser programada e implantada como uma unidade no mesmo nó. Você pode implantar um pod que é um único contêiner de uma só imagem de contêiner. Ou um pod que tem muitos contêineres e muitas imagens de contêiner.

1. No Cloud Shell, execute o seguinte comando para implantar o nginx como um pod chamado nginx-1:

kubectl create deployment --image nginx nginx-1

Esse comando cria um pod chamado nginx com um contêiner que executa a imagem do nginx. Quando não é especificado um repositório, o comportamento padrão é tentar encontrar a imagem localmente ou no registro público do Docker. Neste exemplo, a imagem é extraída do registro público do Docker.

2. No Cloud Shell, execute o seguinte comando para visualizar todos os pods implantados no cluster de contexto ativo:

kubectl get pods

A saída será semelhante ao exemplo a seguir, mas com um nome de pod um pouco diferente.

Resposta:

NAME READY STATUS RESTARTS AGE nginx-1-74c7bbdb84-nvwsc 1/1 Running 0 9s

3. Agora, digite o nome do pod em uma variável que será usada ao longo deste laboratório. O uso de variáveis como esta pode evitar erros humanos ao escrever nomes longos. Digite o nome exclusivo do seu pod no lugar de [your_pod_name]:

export my_nginx_pod=[your_pod_name]

Exemplo:

export my_nginx_pod=nginx-1-74c7bbdb84-nvwsc

4. Para confirmar se a variável de ambiente foi definida corretamente, faça o shell retornar o valor:

echo $my_nginx_pod

Saída:

nginx-1-74c7bbdb84-nvwsc

5. No Cloud Shell, execute o seguinte comando para conferir todos os detalhes do pod que você acabou de criar:

kubectl describe pod $my_nginx_pod

A saída será semelhante ao exemplo a seguir. Os detalhes do pod, assim como o status, as condições e os eventos do ciclo de vida dele, serão exibidos.

Saída:

Name: nginx-1-74c7bbdb84-nvwsc Namespace: default Node: gke-standard-cluster-1-default-pool-bc4ec334-0hmk/10.128.0.5 Start Time: Sun, 16 Dec 2018 14:29:38 -0500 Labels: pod-template-hash=3073668640 run=nginx-1 Annotations: kubernetes.io/limit-ranger=LimitRanger plugin set: cpu ... Status: Running IP: 10.8.3.3 Controlled By: ReplicaSet/nginx-1-74c7bbdb84 Containers: nginx-1: Container ID: docker://dce87d274e6d25300b07ec244c265d42806579fee... Image: nginx:latest Image ID: docker-pullable://nginx@sha256:87e9b6904b4286b8d41... Port: Host Port: State: Running Started: Sun, 16 Dec 2018 14:29:44 -0500 Ready: True Restart Count: 0 Requests: cpu: 100m Environment: Mounts: /var/run/secrets/kubernetes.io/serviceaccount from default-tok... Conditions: Type Status Initialized True Ready True PodScheduled True Volumes: default-token-nphcg: Type: Secret (a volume populated by a Secret) SecretName: default-token-nphcg Optional: false QoS Class: Burstable Node-Selectors: Tolerations: node.kubernetes.io/not-ready:NoExecute for 300s node.kubernetes.io/unreachable:NoExecute for 300s Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal Sche... 1m default-scheduler Successf... Normal Succ... 1m kubelet, gke-standard-cl... MountVol... Normal Pull... 1m kubelet, gke-standard-cl... pulling ... Normal Pull... 1m kubelet, gke-standard-cl... Successf... Normal Crea... 1m kubelet, gke-standard-cl... Created ... Normal Star... 1m kubelet, gke-standard-cl... Started ...

Envie um arquivo para um contêiner

Para exibir conteúdo estático pelo servidor da Web nginx, é preciso criar e colocar um arquivo no contêiner.

1. No Cloud Shell, digite os seguintes comandos para abrir um arquivo chamado test.html no editor de texto nano:

nano ~/test.html

2. Adicione o texto abaixo (script de shell) ao arquivo test.html vazio:

<html> <header><title>This is title</title></header> <body> Hello world </body> </html>

3. Pressione CTRL+X, depois Y e Enter para salvar o arquivo e sair do editor nano.

4. No Cloud Shell, execute o seguinte comando para colocar o arquivo no local adequado do contêiner nginx no pod nginx que vai ser exibido estaticamente:

kubectl cp ~/test.html $my_nginx_pod:/usr/share/nginx/html/test.html

Esse comando copia o arquivo test.html do diretório principal local para o /usr/share/nginx/html do primeiro contêiner no pod nginx. Quando o pod tem vários contêineres, você pode especificar outros usando a opção -c seguida do nome do contêiner.

Exponha o pod para teste

Para expor um pod a clientes fora do cluster, é preciso usar um serviço. Esses serviços são discutidos ao longo do curso e usados em outros laboratórios. Use um comando simples e crie um serviço para expor um pod.

1. No Cloud Shell, execute o seguinte comando para criar um serviço e expor o pod nginx externamente:

kubectl expose pod $my_nginx_pod --port 80 --type LoadBalancer

Esse comando cria um serviço LoadBalancer, que permite o acesso ao pod nginx de endereços da Internet fora do cluster.

2. No Cloud Shell, execute o seguinte comando para exibir detalhes sobre os serviços no cluster:

kubectl get services

A saída será semelhante ao exemplo a seguir. Você vai usar o endereço IP externo na próxima etapa.

Observação: talvez você precise repetir o comando algumas vezes até que o IP externo do novo serviço seja preenchido.

Saída:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.11.240.1 443/TCP 1h nginx-1-7...wsc LoadBalancer 10.11.240.87 80:31695/TCP 3s

O serviço kubernetes é uma das opções padrão criadas ou usadas pelo cluster. O serviço nginx que você criou também aparece na resposta.

Talvez seja preciso executar o comando várias vezes até que o endereço IP externo seja exibido.

Saída:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.11.240.1 443/TCP 1h nginx-1-7...wsc LoadBalancer 10.11.240.87 104.154.177.46 80:31695/TCP 1m

Clique em Verificar meu progresso para conferir o objetivo. Implante pods em clusters do GKE

3. No Cloud Shell, execute o seguinte comando para verificar se o contêiner nginx está exibindo o arquivo HTML estático copiado.

Substitua [EXTERNAL_IP] pelo endereço IP externo do serviço obtido na saída da etapa anterior.

curl http://[EXTERNAL_IP]/test.html

A saída mostra o conteúdo do arquivo. Acesse o mesmo endereço no navegador para acessar o arquivo renderizado como HTML.

Exemplo:

curl http://104.154.177.46/test.html

Hello World

4. No Cloud Shell, execute o seguinte comando para conferir os recursos que estão sendo usados pelo pod nginx:

kubectl top pods

Saída:

NAME CPU(cores) MEMORY(bytes) nginx-1-74c7bbdb84-nvwsc 0m 2Mi

Tarefa 6: Fazer a introspecção de pods do GKE

Nesta tarefa, você vai se conectar a um pod para ajustar configurações, editar arquivos e fazer outras alterações nele em tempo real.

Observação: só use este processo para resolver problemas ou fazer experimentos. Como as alterações não são feitas na imagem de origem do pod, elas não afetam as réplicas.

Prepare o ambiente

A maneira mais comum de implantar pods e outros recursos no Kubernetes é usar os arquivos de configuração, que às vezes são chamados de arquivos de manifesto. Eles costumam usar a sintaxe YAML e especificam os detalhes do recurso. Com esses arquivos, é mais fácil especificar opções complexas, em vez de usar uma longa string de argumentos de linha de comando.

A sintaxe YAML é semelhante, mas mais concisa do que a sintaxe JSON, e permite o mesmo tipo de estruturação hierárquica de objetos e propriedades. O repositório de origem do laboratório tem exemplos de arquivos YAML preparados para você.

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_Shell/

Você vai receber uma amostra de arquivo de manifesto YAML referente a um pod chamado new-nginx-pod.yaml:

apiVersion: v1 kind: Pod metadata: name: new-nginx labels: name: new-nginx spec: containers: - name: new-nginx image: nginx ports: - containerPort: 80

4. Para implantar o manifesto, execute o comando abaixo:

kubectl apply -f ./new-nginx-pod.yaml

Clique em Verificar meu progresso para conferir o objetivo. Implante o arquivo de manifesto referente a um pod chamado new-nginx

5. Para ver uma lista de pods, execute este comando:

kubectl get pods

A saída será semelhante ao exemplo.

Saída:

NAME READY STATUS RESTARTS AGE new-nginx 1/1 Running 0 9s nginx-1-74c7bbdb84-nvwsc 1/1 Running 0 55m

Você verá o novo pod nginx, além daquele criado anteriormente no laboratório.

Use o redirecionamento de shell para se conectar a um pod

Algumas imagens de contêiner incluem um ambiente shell que pode ser iniciado. Talvez ele seja uma opção mais prática do que executar comandos individuais com o kubectl. Por exemplo, a imagem nginx inclui um shell bash. Nesta tarefa, você vai usar o redirecionamento de shell para se conectar ao shell bash no novo pod nginx e realizar uma sequência de ações.

1. No Cloud Shell, execute o seguinte comando para iniciar um shell bash interativo no contêiner nginx:

kubectl exec -it new-nginx /bin/bash

Um novo prompt de shell vai aparecer.

Saída:

root@new-nginx:/#

Você iniciou um shell bash interativo no contêiner do pod new-nginx. Se esse pod tivesse vários contêineres, seria possível especificar um deles pelo nome com a opção -c.

Como a imagem do contêiner nginx não tem ferramentas de edição de texto por padrão, é necessário instalar uma.

2. No Cloud Shell, localize o shell bash do nginx e execute os seguintes comandos para instalar o editor de texto nano:

apt-get update apt-get install nano

Quando a pergunta "Do you want to continue (Y/n)" aparecer, pressione y para confirmar.

É preciso criar um arquivo test.html no diretório estático exibido no contêiner nginx.

3. No Cloud Shell, vá até o shell bash do nginx e execute os seguintes comandos para acessar o diretório de arquivos estáticos e criar um arquivo test.html:

cd /usr/share/nginx/html nano test.html

4. No Cloud Shell, encontre a sessão nano do shell bash nginx e digite o seguinte:

<html> <header><title>This is title</title></header> <body> Hello world </body> </html>

5. Pressione CTRL+X, depois Y e Enter para salvar o arquivo e sair do editor nano.
6. No shell bash do nginx, execute o seguinte comando para sair dele no Cloud Shell:

exit

É possível criar um serviço para estabelecer uma conexão e testar o contêiner nginx modificado com o novo arquivo HTML estático. Uma opção mais fácil é usar o encaminhamento de portas para se conectar ao pod diretamente no Cloud Shell.

7. No Cloud Shell, execute o seguinte comando para configurar o encaminhamento de portas do Cloud Shell ao pod nginx (da porta 10081 da VM do Cloud Shell para a 80 do contêiner nginx):

kubectl port-forward new-nginx 10081:80

A saída será semelhante ao exemplo.

Saída:

Forwarding from 127.0.0.1:10081 -> 80 Forwarding from [::1]:10081 -> 80

Esse é um processo em primeiro plano, então é preciso abrir outra instância do Cloud Shell para fazer testes.

8. 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. Para alternar entre as sessões, clique nos títulos na barra de menu.

9. Na segunda sessão do Cloud Shell, execute o seguinte comando para testar o contêiner nginx modificado pelo encaminhamento de portas:

curl http://127.0.0.1:10081/test.html

Você vai ver o texto HTML que colocou no arquivo test.html.

<html> <header><title>This is title</title></header> <body> Hello world </body> </html>

Acesse os registros de um pod

1. Na barra de menu do Cloud Shell, clique no sinal de mais (+) para iniciar outra sessão.

Agora a janela tem três sessões abertas. Como antes, clique nas sessões na barra de menus para alternar entre elas.

2. Na terceira janela do Cloud Shell, execute o comando abaixo para exibir os registros do pod new-nginx e transmitir as novas entradas (incluindo carimbos de data/hora) à medida que elas chegam:

kubectl logs new-nginx -f --timestamps

3. Os registros vão aparecer nessa nova janela.
4. Volte à segunda sessão do Cloud Shell e execute o comando curl de novo para gerar tráfego no pod.
5. Confira as novas mensagens de registro que vão aparecer na terceira sessão do Cloud Shell.

6. Feche essa última sessão para interromper a exibição das mensagens de registro.
7. Feche a sessão original do Cloud Shell para encerrar o processo de encaminhamento de portas.

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 2026 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de empresas e produtos podem ser marcas registradas das empresas a que estão associados.