GSP021

Informações gerais

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

Neste laboratório, será usado um ambiente gerenciado, como o Kubernetes Engine, para você se concentrar mais em testar o Kubernetes e não ter que configurar a infraestrutura. O Kubernetes Engine é um ambiente gerenciado para implantação de aplicativos conteinerizados. Ele inclui as mais recentes inovações em produtividade para desenvolvedores, eficiência de recursos, operações automatizadas e a flexibilidade do código aberto para acelerar seu tempo de lançamento.

Observação: o app está hospedado no GitHub e oferece um aplicativo de exemplo de 12 fatores. Durante este laboratório, você vai trabalhar com as seguintes imagens do Docker:

kelseyhightower/monolith: o monolith inclui serviços Auth e hello.

kelseyhightower/auth: um microsserviço Auth. Ele gera tokens JWT para usuários autenticados.

kelseyhightower/hello: um microsserviço hello. Ele saúda os usuários autenticados.

ngnix: front-end para serviços Auth e hello.

Objetivos

Neste laboratório, você vai aprender a:

• provisionar um cluster completo do Kubernetes usando o Kubernetes Engine;
• implantar e gerenciar contêineres do Docker usando a kubectl;
• dividir um aplicativo em microsserviços usando as implantações e serviços do Kubernetes.

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o 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, 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 ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

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

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

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, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você verá o seguinte:

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

2. Clique em Abrir Console do Google. O laboratório ativa recursos e depois abre outra guia com a página Fazer login.

   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. Caso seja preciso, copie o Nome de usuário no painel Detalhes do laboratório e cole esse nome na caixa de diálogo Fazer login. Clique em Avançar.

4. Copie a Senha no painel Detalhes do laboratório e a cole na caixa de diálogo Olá. Clique em Avançar.

   Importante: você precisa usar as credenciais do painel à esquerda. Não use suas credenciais do Google Cloud Ensina. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

5. 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 GCP vai ser aberto nesta guia.

Observação: para ver uma lista dos produtos e serviços do Google Cloud, clique no Menu de navegação no canto superior esquerdo.

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.

Depois de se conectar, vai notar 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 YOUR_PROJECT_ID

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

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

gcloud auth list

3. Clique em Autorizar.

4. A saída será parecida com esta:

Saída:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net 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_ID>

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: para conferir a documentação completa da gcloud, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.

Google Kubernetes Engine

1. No ambiente do Cloud Shell, digite o seguinte comando para definir a zona:

gcloud config set compute/zone {{{project_0.default_zone|Zone}}}

2. Inicie um cluster para uso neste laboratório:

gcloud container clusters create io Você estará automaticamente autenticado no seu cluster após a criação. Se, por algum motivo, você perder a conexão do Cloud Shell, execute o comando gcloud container clusters get-credentials io para reautenticar. Observação: a criação do cluster vai levar algum tempo, porque o Kubernetes Engine vai provisionar algumas máquinas virtuais em segundo plano para você usar.

Tarefa 1. Acessar o exemplo de código

1. Copie o código-fonte da linha de comando do Cloud Shell:

gsutil cp -r gs://spls/gsp021/* .

2. Mude para o diretório deste laboratório:

cd orchestrate-with-kubernetes/kubernetes

3. Liste os arquivos para saber com qual deles você está trabalhando:

ls

O exemplo tem o seguinte layout:

deployments/ /* Deployment manifests */ ... nginx/ /* nginx config files */ ... pods/ /* Pod manifests */ ... services/ /* Services manifests */ ... tls/ /* TLS certificates */ ... cleanup.sh /* Cleanup script */

Agora que você tem o código, é hora de começar a usar o Kubernetes.

Tarefa 2. Demonstração rápida do Kubernetes

A maneira mais fácil de começar a usar o Kubernetes é com o comando kubectl create.

1. Use-o para iniciar uma única instância do contêiner nginx:

kubectl create deployment nginx --image=nginx:1.10.0

O Kubernetes vai criar uma implantação. Há mais informações sobre implantações mais adiante. Por enquanto, tudo o que você necessita saber é que as implantações mantêm os pods funcionando mesmo quando há falha nos nós em que eles são executados.

No Kubernetes, todos os contêineres são executados em um pod.

2. Use o comando kubectl get pods para acessar o contêiner nginx em execução:

kubectl get pods

3. Assim que o contêiner nginx estiver com o status "Em execução", é possível expor esse contêiner fora do Kubernetes usando o comando kubectl expose:

kubectl expose deployment nginx --port 80 --type LoadBalancer

O que aconteceu? O Kubernetes criará, em segundo plano, um balanceador de carga externo com um endereço IP público anexado a ele. Qualquer cliente que alcançar esse endereço IP público será encaminhado para os pods que estão por trás do serviço. Nesse caso, seria o pod do nginx.

4. Liste nossos serviços usando o comando kubectl get services:

kubectl get services Observação: talvez leve alguns segundos para que o campo ExternalIP do seu serviço seja preenchido. Isso é normal. Basta executar novamente o comando kubectl get services em intervalos de alguns segundos até o campo ser preenchido.

5. Adicione o IP externo a esse comando para acessar o contêiner Nginx remotamente:

curl http://<External IP>:80

Pronto! O Kubernetes oferece suporte para um fluxo de trabalho fácil e pronto para uso com os comandos kubectl run e expose.

Teste a tarefa concluída

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório. Depois de criar um cluster do Kubernetes e implantar um contêiner Nginx, você vai poder conferir uma pontuação de avaliação.

Criar um cluster do Kubernetes e iniciar o contêiner do Nginx

Depois desse tour rápido pelo Kubernetes, é hora de você conhecer melhor cada um dos componentes e abstrações.

Tarefa 3. Pods

A parte essencial do Kubernetes está no Pod.

Os pods representam e retêm uma coleção de um ou mais contêineres. Geralmente, quando há vários contêineres com forte dependência uns dos outros, você os empacota dentro de um único pod.

Neste exemplo, há um pod com os contêineres monolítico e nginx.

Os pods têm também Volumes. Volumes são discos de dados que duram o tempo que durarem os pods e podem ser usados pelos contêineres desses pods. Os pods fornecem um namespace compartilhado do conteúdo deles, ou seja, os dois contêineres dentro do nosso pod de exemplo podem se comunicar entre si e também compartilham os volumes anexados.

Os pods compartilham também um namespace de rede. Isso significa que há um endereço IP por pod.

A seguir, saiba mais sobre pods.

Tarefa 4. Criar pods

Os pods podem ser criados com arquivos de configuração de pods. Reserve um momento para conhecer o arquivo de configuração do pod monolítico.

1. Acesse o diretório:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Execute o comando a seguir:

cat pods/monolith.yaml

A resposta mostra o arquivo de configuração aberto:

apiVersion: v1 kind: Pod metadata: name: monolith labels: app: monolith spec: containers: - name: monolith image: kelseyhightower/monolith:1.0.0 args: - "-http=0.0.0.0:80" - "-health=0.0.0.0:81" - "-secret=secret" ports: - name: http containerPort: 80 - name: health containerPort: 81 resources: limits: cpu: 0.2 memory: "10Mi"

Há algumas coisas para serem observadas aqui. Você vai notar que:

• seu pod é composto por um contêiner (o monolítico);
• alguns argumentos serão passados para nosso contêiner quando ele iniciar;
• a porta 80 será aberta para o tráfego http.

3. Crie o pod do monolítico usando o comando kubectl:

kubectl create -f pods/monolith.yaml

4. Examine seus pods. Use o comando kubectl get pods para listar todos os pods em execução no namespace padrão:

kubectl get pods Observação: pode levar alguns segundos até que o pod do monolítico esteja em pleno funcionamento. A imagem do contêiner monolítico precisa ser extraída do Docker Hub para que ele possa ser executado.

5. Quando o pod estiver funcionando, use o comando kubectl describe para receber mais informações sobre o pod do monolítico:

kubectl describe pods monolith

Você vai observar várias informações sobre o pod do monolítico, incluindo o endereço IP do pod e o log de eventos. Essas informações serão úteis na solução de problemas.

O Kubernetes facilita a criação de pods, basta descrevê-los nos arquivos de configuração, além de simplificar a visualização das informações sobre eles quando estão em execução. Agora, você vai conseguir criar todos os pods necessários para a implantação.

Tarefa 5. Interagir com os pods

Por padrão, os pods recebem um endereço IP privado e não podem ser acessados fora do cluster. Use o comando kubectl port-forward para associar uma porta local a uma porta dentro do pod do monolítico.

Observação: agora, você vai trabalhar em várias guias do Cloud Shell para configurar a comunicação entre os pods. Qualquer comando executado em um segundo ou terceiro shell será indicado nas instruções.

1. Abra um segundo terminal do Cloud Shell. Agora você tem dois terminais, um para executar o comando kubectl port-forward e o outro para emitir comandos curl.

2. No 2º terminal, execute este comando para configurar o encaminhamento de portas:

kubectl port-forward monolith 10080:80

3. No 1º terminal, comece a se comunicar com seu pod usando curl:

curl http://127.0.0.1:10080

Sim. Você receberá um simpático "hello" do seu contêiner.

4. Agora, use o comando curl para observar o que acontece quando você alcança um endpoint seguro:

curl http://127.0.0.1:10080/secure

Ops.

5. Tente fazer login para receber um token de autenticação do monolítico:

curl -u user http://127.0.0.1:10080/login

6. No prompt de login, use a senha supersecreta password para entrar.

A entrada fez com que o token JWT fosse impresso.

7. Como o Cloud Shell não lida muito bem com a cópia de strings longas, crie uma variável de ambiente para o token.

TOKEN=$(curl http://127.0.0.1:10080/login -u user|jq -r '.token')

8. Digite novamente a senha supersecreta password quando for solicitado.

9. Use este comando para copiar e usar o token de acesso ao endpoint seguro com curl:

curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:10080/secure

Nesse momento, você vai receber uma resposta do nosso aplicativo informando que está tudo certo novamente.

10. Use o comando kubectl logs para acessar os registros do pod do monolith:

kubectl logs monolith

11. Abra um 3º terminal e use a flag -f para receber um stream dos registros adicionados em tempo real:

kubectl logs -f monolith

12. Agora, se você usar curl no 1º terminal para interagir com o monolítico, vai observar a atualização dos registros no 3º terminal:

curl http://127.0.0.1:10080

13. Use o comando kubectl exec para executar um shell interativo dentro do pod do monolítico. Isso pode ser útil para solucionar problemas de dentro de um contêiner:

kubectl exec monolith --stdin --tty -c monolith -- /bin/sh

14. Por exemplo, quando há um shell em um contêiner monolítico, é possível testar a conectividade externa usando o comando ping:

ping -c 3 google.com

15. Não esqueça de sair quando terminar esse shell interativo.

exit

Como você pode observar, a interação com os pods é tão fácil quanto usar o comando kubectl. Seja para acessar remotamente um contêiner ou para receber um shell de login, o Kubernetes fornece tudo o que você precisa para iniciar e seguir em frente.

Tarefa 6. Serviços

Os pods não foram criados para serem persistentes. Eles podem ser interrompidos ou iniciados por muitas razões, por exemplo, falha nas verificações de integridade ou de prontidão, o que gera um problema:

O que acontece quando você quer se comunicar com um conjunto de pods? Quando eles forem reiniciados, é possível que tenham endereço IP diferente.

É aqui que entram os Serviços. Eles fornecem endpoints estáveis para pods.

Os serviços aplicam rótulos para determinar os pods em que eles operam. Se os pods tiverem os rótulos corretos, serão automaticamente selecionados e expostos por nossos serviços.

O nível de acesso de um serviço a um conjunto de pods depende do tipo de serviço. Atualmente, existem três tipos:

• ClusterIP (interno) é o tipo padrão, significa que esse serviço só é visível dentro do cluster.
• NodePort concede a cada nó do cluster um IP externamente acessível.
• LoadBalancer adiciona um balanceador de carga do provedor de nuvem que encaminha o tráfego do serviço para os nós dentro dele.

Agora, você vai aprender a:

• criar um serviço;
• usar seletores de rótulo para expor um conjunto limitado de pods externamente.

Tarefa 7: criar um serviço

Antes de criar serviços, crie um pod seguro que possa lidar com o tráfego HTTPS.

1. Se você modificou diretórios, retorne para o diretório ~/orchestrate-with-kubernetes/kubernetes:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Conheça o arquivo de configuração de serviço do monolítico:

cat pods/secure-monolith.yaml

3. Crie os pods de secure-monolith e os dados de configuração deles:

kubectl create secret generic tls-certs --from-file tls/ kubectl create configmap nginx-proxy-conf --from-file nginx/proxy.conf kubectl create -f pods/secure-monolith.yaml

Agora que você tem um pod seguro, é hora de expor o pod secure-monolith externamente. Para isso, crie um serviço do Kubernetes.

4. Conheça o arquivo de configuração de serviço do monolítico:

cat services/monolith.yaml

(Resposta):

kind: Service apiVersion: v1 metadata: name: "monolith" spec: selector: app: "monolith" secure: "enabled" ports: - protocol: "TCP" port: 443 targetPort: 443 nodePort: 31000 type: NodePort Questões a observar:

* Há um seletor que é usado para localizar e expor automaticamente todos os pods com os rótulos "app: monolith" e "secure: enabled".

Agora é preciso expor o nodeport porque é assim que vamos encaminhar o tráfego externo da porta 31000 para o nginx, na porta 443.

5. Use o comando kubectl create para criar o serviço do monolítico do arquivo de configuração de serviço do monolítico:

kubectl create -f services/monolith.yaml

(Resposta):

service/monolith created

Teste a tarefa concluída

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório. Se o serviço e os pods monolíticos tiverem sido criados corretamente, você terá uma pontuação de avaliação.

Criar o serviço e os pods monolíticos

Você está usando uma porta para expor o serviço. Isso significa que poderá haver colisões de porta se outro app tentar se vincular à porta 31000 em um de seus servidores.

Normalmente, o Kubernetes lidaria com essa atribuição de porta. Neste laboratório, você escolheu uma porta para facilitar a configuração das verificações de integridade mais tarde.

6. Use o comando gcloud compute firewall-rules para permitir tráfego para o serviço do monolítico no nodeport exposto:

gcloud compute firewall-rules create allow-monolith-nodeport \ --allow=tcp:31000

Teste a tarefa concluída

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório. Se a regra do firewall para permitir tráfego TCP na porta 31000 tiver sido criada corretamente, você terá uma pontuação de avaliação.

Permita o tráfego para o serviço monolítico no nodeport exposto

Agora que está tudo configurado, você pode acessar o serviço secure-monolith de fora do cluster sem usar o encaminhamento de portas.

1. Escolha um endereço IP externo para um dos nós.

gcloud compute instances list

2. Agora, tente acessar o serviço secure-monolith usando curl:

curl -k https://<EXTERNAL_IP>:31000

Ops. O tempo limite esgotou. O que deu errado?

Observação: é hora de fazer um teste rápido de conhecimento.

Use os seguintes comandos para responder as perguntas abaixo:

kubectl get services monolith

kubectl describe services monolith

Perguntas:

Por que você não recebeu uma resposta do serviço do monolítico?

O serviço do monolítico tem quantos endpoints?

Quais rótulos um pod precisa ter para ser selecionado pelo serviço do monolítico?

Dica: isso está relacionado a rótulos. Você vai corrigir o problema na próxima seção.

Tarefa 8. Adicionar rótulos aos pods

Atualmente, o serviço do monolítico não tem endpoints. Uma maneira de resolver um problema como este é usar o comando kubectl get pods com uma consulta de rótulo.

1. Observe que você tem alguns pods em execução com o rótulo monolith.

kubectl get pods -l "app=monolith"

2. Mas e o "app=monolith" e o "secure=enabled"?

kubectl get pods -l "app=monolith,secure=enabled"

Observe que essa consulta de rótulo não imprime nenhum resultado. Parece que é preciso adicionar o rótulo "secure=enabled" a eles.

3. Use o comando kubectl label para adicionar ao pod do secure-monolith o rótulo secure=enabled que falta. Depois, verifique se os rótulos foram atualizados.

kubectl label pods secure-monolith 'secure=enabled' kubectl get pods secure-monolith --show-labels

4. Agora que os pods estão rotulados corretamente, observe a lista de endpoints no serviço do monolítico:

kubectl describe services monolith | grep Endpoints

Agora você tem um!

5. Faça o teste acessando um dos nossos nós de novo.

gcloud compute instances list curl -k https://<EXTERNAL_IP>:31000

Pimba! Deu tudo certo.

Teste a tarefa concluída

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório. Se o rótulo tiver sido adicionado aos pods monolíticos corretamente, você terá uma pontuação de avaliação.

Adicionar rótulos aos pods

Tarefa 9. Implantar aplicativos com o Kubernetes

O objetivo deste laboratório é preparar você para escalonar e gerenciar contêineres na produção. É aqui que entram as Implantações. As implantações são uma maneira declarativa de garantir que o número de pods em execução seja igual ao número desejado de pods especificado pelo usuário.

O principal benefício das implantações é a abstração dos detalhes de nível inferior do gerenciamento de pods. As implantações usam conjuntos de réplicas ReplicaSet em segundo plano para gerenciar o início e a interrupção dos pods. Se for necessário atualizar ou escalonar os pods, a implantação cuidará disso. A implantação também trata do reinício dos pods, caso eles parem por algum motivo.

Observe um exemplo rápido:

Os pods estão vinculados ao ciclo de vida do nó no qual foram criados. No exemplo acima, o Node3 parou, e também um pod com ele. Em vez de criar manualmente um novo pod e encontrar um nó para ele, sua implantação criou um novo pod e o iniciou no Node2.

Isso é bem legal!

É hora de combinar tudo o que você aprendeu sobre pods e serviços para dividir o aplicativo monolítico em serviços menores usando as implantações.

Tarefa 10. Criar implantações

Vamos dividir o app monolítico em três partes separadas:

• Auth: gera tokens JWT para usuários autenticados.
• hello: saúda os usuários autenticados.
• front-end: encaminha o tráfego para os serviços Auth e hello.

Tudo pronto para criar implantações, uma para cada serviço. Depois, você vai definir serviços internos para as implantações de Auth e hello e um serviço externo para a implantação de front-end. Depois de finalizado, será possível interagir com os microsserviços, como faz com o monolítico. Mas agora, cada parte pode ser escalonada e implantada de maneira independente.

1. Comece examinando o arquivo de configuração de implantação de Auth.

cat deployments/auth.yaml

(Resposta)

apiVersion: apps/v1 kind: Deployment metadata: name: auth spec: selector: matchlabels: app: auth replicas: 1 template: metadata: labels: app: auth track: stable spec: containers: - name: auth image: "kelseyhightower/auth:2.0.0" ports: - name: http containerPort: 80 - name: health containerPort: 81 ...

A implantação está criando uma réplica, e você está usando a versão 2.0.0 do contêiner Auth.

Quando você executa o comando kubectl create para criar a implantação de Auth, ele cria um pod de acordo com os dados contidos no manifesto de implantação. Isso significa que é possível escalonar o número de pods mudando o número especificado no campo "Replicas".

2. De qualquer maneira, vá em frente e crie seu objeto de implantação:

kubectl create -f deployments/auth.yaml

3. É hora de criar um serviço para sua implantação de Auth. Use o comando kubectl create para criar o serviço Auth:

kubectl create -f services/auth.yaml

4. Repita o procedimento para criar e expor a implantação de hello:

kubectl create -f deployments/hello.yaml kubectl create -f services/hello.yaml

5. Repita o processo mais uma vez para criar e expor a implantação de front-end.

kubectl create configmap nginx-frontend-conf --from-file=nginx/frontend.conf kubectl create -f deployments/frontend.yaml kubectl create -f services/frontend.yaml Observação: há mais uma etapa para criar o front-end porque você precisa armazenar alguns dados de configuração com o contêiner.

6. Interaja com o front-end capturando o IP externo e usando o comando "curl".

kubectl get services frontend Observação: a geração do endereço IP externo talvez leve até um minuto. Execute o comando acima novamente se o status da coluna EXTERNAL-IP for pendente. curl -k https://<EXTERNAL-IP>

Você vai receber uma saudação "hello" como resposta.

Teste a tarefa concluída

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório. Se as implantações Auth, hello e front-end tiverem sido criadas corretamente, você terá uma pontuação de avaliação.

Criar implantações (Auth, hello e front-end)

Parabéns!

Parabéns! Você desenvolveu um aplicativo de diversos serviços usando o Kubernetes. Use o conhecimento que você adquiriu aqui para implantar aplicativos complexos no Kubernetes utilizando uma coleção de implantações e serviços.

Próximas etapas / Saiba mais

• Fique por dentro das novidades do Kubernetes no X (em inglês) e no blog da comunidade.
• Lembre-se: 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.

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 26 de janeiro de 2023

Laboratório testado em 26 de janeiro de 2023

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