GSP005

Visão geral

O objetivo deste laboratório prático é transformar o código que você desenvolveu em um aplicativo conteinerizado replicado, executado no Kubernetes Engine. Para este laboratório, o código será um simples aplicativo Hello World em Node.js.

Veja um diagrama das várias partes deste laboratório, para ajudar você a entender como as peças se encaixam umas nas outras. Use o diagrama como referência à medida que avança pelo laboratório. Tudo fará sentido quando chegar ao fim e, por enquanto, você pode ignorar.

O Kubernetes é um projeto de código aberto (disponível em kubernetes.io) que pode ser executado em vários ambientes, desde laptops até clusters de vários nós com alta disponibilidade, de nuvens públicas a implantações locais, de máquinas virtuais a bare metal.

Neste laboratório, o uso de um ambiente gerenciado como o Kubernetes Engine, uma versão do Kubernetes hospedada pelo Google em execução no Compute Engine, permite que você se dedique mais na experiência do Kubernetes, em vez de configurar a infraestrutura subjacente.

O que você vai aprender

• Criar um servidor do Node.js
• Criar uma imagem de contêiner do Docker
• Criar um cluster de contêiner.
• Criar um pod do Kubernetes
• Escalonar verticalmente seus serviços

Pré-requisitos

• O recomendado é ter familiaridade com os editores de texto padrão do Linux, como vim, emacs ou nano.

Os próprios estudantes devem digitar os comandos para fixar o aprendizado dos conceitos principais. Muitos laboratórios vão incluir um bloco de código com os comandos necessários. Você pode copiá-los desse bloco e colar nos locais apropriados durante o laboratório.

Configuração e requisitos

Antes de clicar no botão Começar o Laboratório

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é ativado quando você clica em Iniciar laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, e não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima (recomendado) ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório: não se esqueça que, depois de começar, não será possível pausar o laboratório.

Observação: use apenas a conta de estudante neste laboratório. Se usar outra conta do Google Cloud, você poderá receber cobranças nela.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar por ele, uma caixa de diálogo vai aparecer para você selecionar a forma de pagamento. No painel Detalhes do Laboratório, à esquerda, você vai encontrar o seguinte:

   • O botão Abrir Console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer Login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Username"}}}

   Você também encontra o nome de usuário no painel Detalhes do Laboratório.

4. Clique em Próxima.

5. Copie a Senha abaixo e cole na caixa de diálogo de Olá.

   {{{user_0.password | "Password"}}}

   Você também encontra a senha no painel Detalhes do Laboratório.

6. Clique em Próxima.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: para acessar os produtos e serviços do Google Cloud, clique no Menu de navegação ou digite o nome do serviço ou produto no campo Pesquisar.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

2. Clique nas seguintes janelas:

   • Continue na janela de informações do Cloud Shell.
   • Autorize o Cloud Shell a usar suas credenciais para fazer chamadas de APIs do Google Cloud.

Depois de se conectar, você verá que sua conta já está autenticada e que o projeto está configurado com seu Project_ID, . A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

A gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

3. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

4. Clique em Autorizar.

Saída:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Observação: consulte a documentação completa da gcloud no Google Cloud no guia de visão geral da gcloud CLI.

Tarefa 1: criar o aplicativo Node.js

1. Usando o Cloud Shell, crie um servidor Node.js simples para implantar no Kubernetes Engine:

vi server.js

2. Inicie o editor:

i

3. Adicione este conteúdo ao arquivo:

var http = require('http'); var handleRequest = function(request, response) { response.writeHead(200); response.end("Hello World!"); } var www = http.createServer(handleRequest); www.listen(8080); Observação: vi é usado aqui, mas as opções nano e emacs também estão disponíveis no Cloud Shell. Outra opção é usar o recurso do editor da Web do Cloud Shell, conforme descrito no guia Como o Cloud Shell funciona.

4. Salve o arquivo server.js pressionando Esc e depois:

:wq

5. Como o Cloud Shell tem o node executado instalado, execute este comando para iniciar o servidor do nó (o comando não gera uma saída):

node server.js

6. Use o recurso de visualização da Web integrado do Cloud Shell para abrir uma nova guia do navegador e fazer proxy de uma solicitação para a instância que você iniciou na porta 8080.

Uma nova guia do navegador será aberta para mostrar seus resultados:

7. Antes de continuar, retorne ao Cloud Shell e digite CTRL+C para interromper o servidor do nó em execução.

Em seguida, empacote esse aplicativo em um contêiner do Docker.

Tarefa 2: criar uma imagem de contêiner do Docker

1. Em seguida, crie um Dockerfile que descreve a imagem que você quer criar. As imagens de contêiner do Docker podem ser extensões de outras imagens. Por isso, para esta imagem, usaremos uma imagem de nó atual.

vi Dockerfile

2. Inicie o editor:

i

3. Adicione este conteúdo:

FROM node:6.9.2 EXPOSE 8080 COPY server.js . CMD ["node", "server.js"]

Este "roteiro" para a imagem Docker vai:

• iniciar a partir da imagem node encontrada no hub do Docker;
• expor a porta 8080;
• copiar o arquivo server.js para a imagem;
• iniciar o servidor do nó como fizemos manualmente antes.

4. Salve este Dockerfile pressionando ESC e digite:

:wq

5. Crie a imagem usando este comando:

docker build -t hello-node:v1 .

O download e a extração levarão algum tempo, mas você verá as barras de progresso à medida que a imagem for criada.

Após a conclusão, teste a imagem localmente executando um contêiner do Docker como um daemon na porta 8080 na imagem de contêiner que você criou.

6. Execute o contêiner do Docker com este comando:

docker run -d -p 8080:8080 hello-node:v1

A saída será parecida com esta:

325301e6b2bffd1d0049c621866831316d653c0b25a496d04ce0ec6854cb7998

7. Para conferir os resultados, use o recurso de visualização da Web do Cloud Shell ou use curl no comando do Cloud Shell:

curl http://localhost:8080

Você verá esta saída:

Hello World! . Observação: a documentação completa do comando docker run está disponível na referência de execução do Docker.

Depois, pare o contêiner em execução.

1. Para encontrar o ID do contêiner do Docker, execute:

docker ps

A saída será parecida com esta:

CONTAINER ID IMAGE COMMAND 2c66d0efcbd4 hello-node:v1 "/bin/sh -c 'node

2. Para interromper o contêiner, execute o seguinte comando, substituindo [CONTAINER ID] pelo valor fornecido na etapa anterior:

docker stop [CONTAINER ID]

A saída do console vai ser parecida com esta (seu ID do contêiner):

2c66d0efcbd4

Agora que a imagem está funcionando conforme esperado, envie-a para o Google Artifact Registry, um repositório particular das suas imagens Docker que pode ser acessado nos seus projetos do Google Cloud.

1. Primeiro, você precisa criar um repositório no Artifact Registry. Vamos chamá-lo de my-docker-repo. Execute este comando:

gcloud artifacts repositories create my-docker-repo \ --repository-format=docker \ --location={{{ project_0.default_region | YOUR_REGION }}} \ --project={{{ project_0.project_id | YOUR_PROJECT_ID }}}

2. Execute o comando a seguir para configurar a autenticação do Docker.

gcloud auth configure-docker

Se aparecer, Do you want to continue (Y/N)? Digite Y.

3. Para incluir uma tag com o nome do repositório na imagem, execute este comando, substituindo PROJECT_ID pelo ID do projeto, que você encontra no console ou na seção Detalhes do laboratório:

docker tag hello-node:v1 {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v1

4. E envie a imagem do contêiner para o repositório executando o seguinte comando:

docker push {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v1

O push inicial pode levar alguns minutos para ser concluído. Você verá as barras de progresso durante a criação.

The push refers to a repository [pkg.dev/qwiklabs-gcp-6h281a111f098/hello-node] ba6ca48af64e: Pushed 381c97ba7dc3: Pushed 604c78617f34: Pushed fa18e5ffd316: Pushed 0a5e2b2ddeaa: Pushed 53c779688d06: Pushed 60a0858edcd5: Pushed b6ca02dfe5e6: Pushed v1: digest: sha256:8a9349a355c8e06a48a1e8906652b9259bba6d594097f115060acca8e3e941a2 size: 2002

3. A imagem do contêiner estará listada no seu console. Clique em menu de navegação > Artifact Registry.

Agora você tem uma imagem Docker em todo o projeto, que o Kubernetes pode acessar e orquestrar.

Observação: usamos a maneira recomendada de trabalhar com o Artifact Registry, que especifica a região a ser usada. Veja como enviar e extrair imagens do Artifact Registry.

Tarefa 3: criar o cluster

Agora está tudo pronto para criar seu cluster do Kubernetes Engine. Um cluster consiste em um servidor de API mestre do Kubernetes hospedado pelo Google e um conjunto de nós de trabalho. Os nós de trabalho são máquinas virtuais do Compute Engine.

1. Configure seu projeto usando gcloud. Substitua PROJECT_ID pelo ID do projeto, disponível no console e na seção Detalhes do laboratório:

gcloud config set project PROJECT_ID

2. Crie um cluster com dois nós e2-medium. Esse processo vai levar alguns minutos:

gcloud container clusters create hello-world \ --num-nodes 2 \ --machine-type e2-medium \ --zone "{{{project_0.default_zone|ZONE}}}"

É possível ignorar os avisos que aparecem quando o cluster é criado.

A saída do console será algo como:

Creating cluster hello-world...done. Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/"{{{project_0.default_zone|ZONE}}}"/clusters/hello-world]. kubeconfig entry generated for hello-world. NAME ZONE MASTER_VERSION MASTER_IP MACHINE_TYPE STATUS hello-world "{{{project_0.default_zone|ZONE}}}" 1.5.7 146.148.46.124 e2-medium RUNNING

Outra opção é criar o cluster pelo console. Para isso, abra o menu de navegação e selecione Kubernetes Engine > Clusters do Kubernetes > Criar.

Observação: recomendamos criar o cluster na mesma zona que o bucket de armazenamento usado pelo Artifact Registry (consulte a etapa anterior).

Se você selecionar menu de navegação > Kubernetes Engine, verá que agora há um cluster do Kubernetes totalmente funcional com a tecnologia do Kubernetes Engine.

É hora de implantar seu próprio aplicativo conteinerizado no cluster do Kubernetes. A partir de agora, usaremos a linha de comando kubectl, já configurada no ambiente do Cloud Shell.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Crie o cluster.

Tarefa 4: criar o pod

Um pod do Kubernetes é um grupo de contêineres agrupados para fins de administração e comunicação em rede. Ele pode ter um ou vários contêineres. Aqui, você usará um contêiner criado com a imagem do Node.js armazenada no seu Artifact Registry particular. Ele vai veicular conteúdo na porta 8080.

1. Crie um pod com o comando kubectl run. Substitua PROJECT_ID pelo ID do projeto, que você encontra no console e na seção Detalhes da conexão do laboratório:

kubectl create deployment hello-node \ --image={{{ project_0.default_region}}}-docker.pkg.dev/PROJECT_ID/my-docker-repo/hello-node:v1

Saída:

deployment.apps/hello-node created

Como você pode ver, criamos um objeto de implantação. Implantações são a maneira recomendada de criar e escalonar pods. Aqui, uma nova implantação gerencia uma réplica de pod único que executa a imagem hello-node:v1.

2. Para ver a implantação, execute:

kubectl get deployments

Saída:

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 1/1 1 1 1m36s

3. Para ver o pod criado pela implantação, execute:

kubectl get pods

Saída:

NAME READY STATUS RESTARTS AGE hello-node-714049816-ztzrb 1/1 Running 0 6m

Agora é um bom momento para testar alguns comandos kubectl interessantes. Nenhum deles vai alterar o estado do cluster. Para conferir a documentação de referência completa, consulte Ferramenta de linha de comando (kubectl):

kubectl cluster-info kubectl config view

E para a solução de problemas:

kubectl get events kubectl logs <pod-name>

Em seguida, é preciso tornar seu pod acessível por ambientes externos.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Criar pod

Tarefa 5: permitir o tráfego externo

Por padrão, o pod é acessível somente do seu IP interno dentro do cluster. Para tornar o contêiner hello-node acessível de fora da rede virtual do Kubernetes, é necessário expor o pod como um serviço do Kubernetes.

1. Com o Cloud Shell, podemos expor o pod à Internet pública com o comando kubectl expose, combinado com o sinalizador --type="LoadBalancer". Esse sinalizador é obrigatório para a criação de um IP acessível externamente:

kubectl expose deployment hello-node --type="LoadBalancer" --port=8080

Saída:

service/hello-node exposed

A flag usada nesse comando especifica que ele está usando o balanceador de carga fornecido pela infraestrutura (nesse caso, o balanceador de carga do Compute Engine). Observe que a implantação será exposta, não o pod diretamente. Isso fará com que o serviço resultante faça o balanceamento de carga do tráfego em todos os pods gerenciados pela implantação (nesse caso, apenas um pod, mas você adicionará mais réplicas posteriormente).

O mestre do Kubernetes cria o balanceador de carga e as regras de encaminhamento do Compute Engine relacionadas, pools de destino e regras de firewall para tornar o serviço totalmente acessível de fora do Google Cloud.

2. Para encontrar o endereço IP publicamente acessível do serviço, solicite ao kubectl para listar todos os serviços de cluster:

kubectl get services

Você verá esta saída:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-node 10.3.250.149 104.154.90.147 8080/TCP 1m kubernetes 10.3.240.1 < none > 443/TCP 5m

Há dois endereços IP listados para o serviço hello-node, ambos usando a porta 8080. O CLUSTER-IP é o IP interno, que é visível apenas dentro da sua rede virtual na nuvem. O EXTERNAL-IP é o IP com balanceamento de carga externo.

Observação: o EXTERNAL-IP pode levar vários minutos para ficar disponível e visível. Se o EXTERNAL-IP estiver ausente, aguarde alguns minutos e execute o comando outra vez.

3. Agora, você deve conseguir acessar o serviço com este endereço no navegador: http://<EXTERNAL_IP>:8080

Até agora, você ganhou acesso a vários recursos ao migrar para contêineres e o Kubernetes. Não é preciso especificar em qual host executar a carga de trabalho, e você também se beneficia do monitoramento e da reinicialização do serviço. Agora confira os benefícios da nova infraestrutura do Kubernetes.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Criar serviço do Kubernetes

Tarefa 6: escalonar o serviço verticalmente

Um dos poderosos recursos oferecidos pelo Kubernetes é a facilidade de escalonar seu aplicativo. Suponha que, de repente, você precise de mais capacidade. Você pode dizer ao controlador de replicação para gerenciar um novo número de réplicas para seu pod.

1. Defina o número de réplicas do pod:

kubectl scale deployment hello-node --replicas=4

Saída:

deployment.extensions/hello-node scaled

2. Peça uma descrição da implantação atualizada:

kubectl get deployment

Saída:

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 4/4 4 4 16m

Execute o comando acima de novo até que as quatro réplicas sejam criadas.

3. Liste todos os pods:

kubectl get pods

Você verá esta saída:

NAME READY STATUS RESTARTS AGE hello-node-714049816-g4azy 1/1 Running 0 1m hello-node-714049816-rk0u6 1/1 Running 0 1m hello-node-714049816-sh812 1/1 Running 0 1m hello-node-714049816-ztzrb 1/1 Running 0 16m

Uma abordagem declarativa está sendo usada aqui. Em vez de iniciar ou interromper novas instâncias, você declara quantas instâncias precisam estar em execução o tempo todo. Os loops de reconciliação do Kubernetes garantem que a realidade corresponda ao que você solicitou e entram em ação, se necessário.

Este diagrama resume o estado do nosso cluster Kubernetes:

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Escalonar o serviço verticalmente

Tarefa 7: implementar uma atualização no serviço

Em algum momento, o aplicativo implantado na produção exigirá correções de bugs ou recursos adicionais. O Kubernetes ajuda você a implantar uma nova versão na produção sem afetar os usuários.

1. Primeiro, modifique o aplicativo abrindo server.js:

vi server.js i

2. Em seguida, atualize a mensagem de resposta:

response.end("Hello Kubernetes World!");

3. Salve o arquivo server.js pressionando Esc e depois:

:wq

Agora, podemos criar e publicar uma nova imagem de contêiner no registro com uma tag incrementada (v2, nesse caso):

4. Execute os comandos a seguir, substituindo PROJECT_ID pelo ID do projeto do laboratório:

docker build -t hello-node:v2 . docker tag hello-node:v2 {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v2 docker push {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v2 Observação: a criação e o envio da imagem atualizada deverão ser mais rápidos, porque o armazenamento em cache está sendo usado.

O Kubernetes vai atualizar o controlador de replicação automaticamente para a nova versão do aplicativo. Para alterar o rótulo da imagem do contêiner em execução, edite hello-node deployment e mude a imagem de pkg.dev/PROJECT_ID/hello-node:v1 para pkg.dev/PROJECT_ID/hello-node:v2.

1. Para isso, use o comando kubectl edit:

kubectl edit deployment hello-node

Ele abre um editor de texto que mostra a configuração YAML completa da implantação. Não é preciso entender a configuração YAML completa agora. Apenas saiba que, ao atualizar o campo spec.template.spec.containers.image na configuração, você solicita à implantação que atualize os pods com a nova imagem.

2. Procure Spec > containers > image e altere o número da versão de v1 para v2:

# Edite o objeto abaixo. Linhas que começam com '#' serão ignoradas, # e um arquivo vazio vão cancelar a edição. Se ocorrer um erro ao salvar, este arquivo será # reaberto com as falhas relevantes. # apiVersion: extensions/v1beta1 kind: Deployment metadata: annotations: deployment.kubernetes.io/revision: "1" creationTimestamp: 2016-03-24T17:55:28Z generation: 3 labels: run: hello-node name: hello-node namespace: default resourceVersion: "151017" selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-node uid: 981fe302-f1e9-11e5-9a78-42010af00005 spec: replicas: 4 selector: matchLabels: run: hello-node strategy: rollingUpdate: maxSurge: 1 maxUnavailable: 1 type: RollingUpdate template: metadata: creationTimestamp: null labels: run: hello-node spec: containers: - image: pkg.dev/PROJECT_ID/hello-node:v1 ## Update this line ## imagePullPolicy: IfNotPresent name: hello-node ports: - containerPort: 8080 protocol: TCP resources: {} terminationMessagePath: /dev/termination-log dnsPolicy: ClusterFirst restartPolicy: Always securityContext: {} terminationGracePeriodSeconds: 30

3. Depois de fazer a mudança, salve e feche o arquivo. Pressione ESC e, em seguida:

:wq

Você verá esta saída:

deployment.extensions/hello-node edited

4. Execute o seguinte comando para atualizar a implantação com a nova imagem:

kubectl get deployments

Novos pods serão criados com a nova imagem e os pods antigos serão excluídos.

Você verá esta saída. Talvez seja necessário executar novamente o comando acima para ver o seguinte:

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 4/4 4 4 1h

Enquanto isso acontece, os usuários dos serviços não sofrerão nenhuma interrupção. Depois de algum tempo, eles começarão a acessar a nova versão do aplicativo. Encontre mais detalhes sobre as atualizações graduais na documentação Como realizar uma atualização gradual.

Com esses recursos de implantação, escalonamento e atualização e após a configuração do seu cluster do Kubernetes Engine, esperamos que você também tenha a certeza de que o Kubernetes ajuda a focar no aplicativo, e não na infraestrutura.

Parabéns!

Isso conclui este laboratório prático com o Kubernetes. Essa é apenas uma pequena parte dessa tecnologia. Teste com seus próprios pods, controladores de replicação e serviços. Confira também as sondagens de atividade (verificações de integridade) e use a API Kubernetes diretamente.

Comece o próximo laboratório

Consulte Gerenciar implantações usando o Kubernetes Engine ou confira estas sugestões:

• Orquestração na nuvem com o Kubernetes
• Como configurar um cluster particular do Kubernetes

Próximas etapas/saiba mais

• Depois de terminar este laboratório, confira o Minikube, que oferece uma instalação simples de um cluster do Kubernetes com um único nó para fins de desenvolvimento e teste: http://kubernetes.io/docs/getting-started-guides/minikube/.
• O Kubernetes é um projeto de código aberto (http://kubernetes.io/) hospedado no GitHub. Sua participação com feedback e contribuições é sempre bem-vinda.
• Acompanhe as notícias sobre o Kubernetes no X (antigo Twitter) e no blog da comunidade.

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 8 de maio de 2025

Laboratório testado em 8 de maio de 2025

Copyright 2025 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.