GSP041

Visão geral

O balanceador de carga de aplicativo interno é essencial para criar aplicativos internos robustos, seguros e fáceis de gerenciar, que impulsionam suas operações comerciais. Neste laboratório, vamos mostrar como distribuir o tráfego na sua rede de nuvem privada sem expor as máquinas virtuais (VMs) diretamente à Internet pública, mantendo os serviços seguros e eficientes.

Neste laboratório, você vai criar um padrão arquitetônico simplificado, mas muito comum:

• Uma "camada da Web" (site voltado ao público) que precisa pedir ajuda a outro serviço interno.
• Um "nível de serviço interno" (uma calculadora de números primos) que realiza tarefas específicas e é distribuído em várias máquinas.

Essa configuração garante que, mesmo que uma parte do seu serviço interno fique ocupada ou inativa, o sistema geral continue funcionando sem problemas, porque o balanceador de carga direciona automaticamente as solicitações para máquinas em boas condições.

Atividades deste laboratório

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

• Conhecer melhor os componentes de um balanceador de carga interno.
• Criar um grupo de máquinas de back-end (calculadora de números primos).
• Configurar um balanceador de carga interno para direcionar o tráfego interno às máquinas de back-end.
• Testar o balanceador de carga interno de outra máquina interna.
• Configurar um servidor da Web voltado ao público que usa o balanceador de carga interno para receber resultados do serviço interno "calculadora de números primos".

Pré-requisitos

• Conhecimento básico do Google Cloud Compute Engine: entender o que é uma instância de máquina virtual (VM).
• Conceitos básicos de rede: o que é um endereço IP.
• Linha de comando básica do Unix/Linux: como digitar comandos em um terminal.
• Conhecimento sobre VPCs (nuvens privadas virtuais): entender que os recursos do Google Cloud ficam em uma rede privada.

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.

Configurar região e zona

• Defina a região e a zona do projeto para este laboratório:

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

Saiba mais na documentação Regiões e zonas.

Observação: quando você executa a gcloud na sua máquina, as configurações continuam as mesmas em todas as sessões. Porém, no Cloud Shell, elas precisam ser definidas a cada nova sessão ou reconexão.

Tarefa 1: criar um ambiente virtual

Um ambiente virtual mantém o software do projeto organizado e garante que o código sempre seja executado com as versões específicas das ferramentas necessárias.

Os ambientes virtuais Python são usados para isolar do sistema a instalação de pacotes.

1. Instale o ambiente virtualenv:

sudo apt-get install -y virtualenv

2. Crie o ambiente virtual:

python3 -m venv venv

3. Ative o ambiente virtual:

source venv/bin/activate

Ativar o Gemini Code Assist no Cloud Shell IDE

Você pode usar o Gemini Code Assist em um ambiente de desenvolvimento integrado (IDE), como o Cloud Shell, para receber orientações sobre o código ou resolver problemas com ele. Antes de começar a usar o Gemini Code Assist, você precisa ativá-lo.

1. No Cloud Shell, ative a API Gemini para Google Cloud com o seguinte comando:

gcloud services enable cloudaicompanion.googleapis.com

2. Clique em Abrir editor na barra de ferramentas do Cloud Shell.

Observação: para abrir o editor do Cloud Shell, clique em Abrir editor na barra de ferramentas do Cloud Shell. Você pode alternar o Cloud Shell e o editor de código clicando em Abrir editor ou Abrir terminal, conforme necessário.

3. No painel à esquerda, clique no ícone Configurações e, na visualização Configurações, pesquise Gemini Code Assist.

4. Localize e verifique se a caixa de seleção Geminicodeassist: Ativar está marcada e feche as Configurações.

5. Clique em Cloud Code - Sem projeto na barra de status na parte de baixo da tela.

6. Autorize o plug-in conforme instruído. Se um projeto não for selecionado automaticamente, clique em Selecionar um projeto do Google Cloud e escolha .

7. Verifique se o projeto do Google Cloud () aparece na mensagem de status do Cloud Code na barra de status.

Tarefa 2: criar um grupo gerenciado de instâncias de back-end

Ao usar um "grupo gerenciado de instâncias", o Google Cloud pode criar e manter automaticamente cópias idênticas do seu serviço. Se uma cópia falhar, o Google Cloud a substituirá, tornando seu serviço mais confiável.

Criar o script de inicialização

Pense nesse script como um conjunto de instruções que cada nova VM do grupo segue ao ser iniciada. Seu script tem um pequeno servidor da Web escrito em Python que pode informar se um número é primo (True) ou não (False).

1. No terminal do Cloud Shell, execute o seguinte comando para criar o script backend.sh no diretório principal:

touch ~/backend.sh

2. Clique no ícone Abrir editor na parte de cima da barra de ferramentas do Cloud Shell. Se for solicitado, clique em Abrir em uma nova janela.

Observação: se o ícone "Editor de código" não aparecer, clique no ícone Menu de navegação (☰) para fechar o painel esquerdo.

Depois de alguns segundos, o espaço de trabalho vai aparecer.

3. Selecione o arquivo backend.sh no painel "Buscador de arquivos".

4. Agora, adicione o seguinte script ao editor:

sudo chmod -R 777 /usr/local/sbin/ sudo cat << EOF > /usr/local/sbin/serveprimes.py import http.server def is_prime(a): return a!=1 and all(a % i for i in range(2,int(a**0.5)+1)) class myHandler(http.server.BaseHTTPRequestHandler): def do_GET(s): s.send_response(200) s.send_header("Content-type", "text/plain") s.end_headers() s.wfile.write(bytes(str(is_prime(int(s.path[1:]))).encode('utf-8'))) http.server.HTTPServer(("",80),myHandler).serve_forever() EOF nohup python3 /usr/local/sbin/serveprimes.py >/dev/null 2>&1 &

5. Clique em Arquivo > Salvar, mas não feche o arquivo.

6. Com o Gemini Code Assist ativado no ambiente de desenvolvimento integrado, quando você abrir um arquivo no editor, como backend.sh, observe o ícone no canto superior direito da barra de ferramentas, que indica que o Gemini Code Assist está pronto para uso.

   O Gemini Code Assist aumenta a produtividade e reduz a troca de contexto oferecendo ações inteligentes com tecnologia de IA diretamente no editor de código. Em seguida, você vai usar o Gemini Code Assist para explicar a finalidade e a funcionalidade de um script de inicialização de VM no grupo gerenciado de instâncias para um membro da equipe.

7. Clique no ícone Gemini Code Assist: ações inteligentes e selecione Explicar isto.

8. O Gemini Code Assist abre um painel de chat com o comando Explicar isto preenchido. Na caixa de texto inline do chat do Code Assist, substitua o comando preenchido previamente pelo seguinte e clique em Enviar:

Como desenvolvedor de aplicativos na Cymbal AI, explique o script de inicialização backend.sh para um novo membro da equipe. Esse script é usado para executar um pequeno servidor da Web escrito em um arquivo Python serveprimes.py. Mostre em detalhes os principais componentes do script e explique a função de cada comando. Para as melhorias sugeridas, não faça alterações no conteúdo do arquivo.

Uma explicação detalhada do script de inicialização backend.sh usado para executar um pequeno servidor da Web aparece no chat do Gemini Code Assist.

Criar o modelo da instância

9. Na barra de ferramentas do Cloud Shell, clique em Abrir terminal. Para criar o modelo de instância primecalc, execute o seguinte comando:

gcloud compute instance-templates create primecalc \ --metadata-from-file startup-script=backend.sh \ --no-address --tags backend --machine-type=e2-medium

Esse é o "blueprint" das VMs de back-end. Ele contém --no-address, o que significa que essas VMs de back-end não terão acesso público à Internet por motivos de segurança.

Abrir o firewall

Crie uma regra de firewall para permitir que o tráfego na porta 80 (tráfego HTTP padrão) alcance as VMs de back-end. Isso é crucial para que o balanceador de carga de aplicativo interno e as verificações de integridade se comuniquem com elas.

10. Execute o seguinte comando para abrir o firewall para a porta 80:

gcloud compute firewall-rules create http --network default --allow=tcp:80 \ --source-ranges {{{project_0.startup_script.selected_cidr | IP}}} --target-tags backend

Clique em Verificar meu progresso para saber se você está no caminho certo neste laboratório.

Criar um modelo de instância e abrir o firewall na porta 80

Criar o grupo de instâncias

11. Depois, execute o seguinte comando para criar o grupo gerenciado de instâncias chamado backend. Comece com três instâncias:

gcloud compute instance-groups managed create backend \ --size 3 \ --template primecalc \ --zone {{{project_0.default_zone | ZONE }}}

12. Quando a execução terminar, volte para a guia "Console". Acesse Compute Engine > Instâncias de VM. Agora você vai ver três VMs de back-end sendo criadas pelo grupo de instâncias.

Os back-ends estão prontos para disponibilizar o tráfego.

Clique em Verificar meu progresso para saber se você está no caminho certo neste laboratório.

Criar o grupo de instâncias

Tarefa 3: configurar o balanceador de carga interno

Você vai criar uma única entrada VIP privada para seu serviço interno. Ela permite que outros aplicativos internos alcancem sua "calculadora de números primos" de maneira confiável, sem precisar saber qual VM de back-end específica está ativa ou disponível.

Nesta tarefa, você vai configurar o balanceador de carga interno e conectá-lo ao grupo de instâncias que acabou de criar.

Um balanceador de carga interno consiste em três partes principais:

• Regra de encaminhamento: é o endereço IP particular real para onde outros serviços internos enviam solicitações. Ela "encaminha" o tráfego para o serviço de back-end.
• Serviço de back-end: define como o balanceador de carga distribui o tráfego para as instâncias de VM. Também inclui a verificação de integridade.
• Verificação de integridade: é uma verificação contínua que monitora a "integridade" das VMs de back-end. O balanceador de carga só envia tráfego para máquinas que são aprovadas nas verificações de integridade, garantindo que seu serviço esteja sempre disponível.

O diagrama a seguir mostra como as instâncias passam pelo balanceador de carga usando várias instâncias em diversos grupos de back-end em zonas diferentes.

Criar uma verificação de integridade

1. Uma verificação de integridade é necessária para garantir que o balanceador de carga envie o tráfego apenas para instâncias em boas condições. Como o serviço de back-end é um servidor HTTP, execute o seguinte comando para verificar se ele responde com "200 OK" em um caminho de URL específico (neste caso, /2 para verificar se 2 é primo):

gcloud compute health-checks create http ilb-health --request-path /2

Como o serviço HTTP é fornecido, verifique se uma resposta "200" em um caminho de URL específico (neste caso, /2 para verificar se 2 é um número primo) é preenchida.

Criar um serviço de back-end

2. Agora execute o seguinte comando para criar o serviço de back-end chamado prime-service:

gcloud compute backend-services create prime-service \ --load-balancing-scheme internal --region={{{project_0.default_region | REGION}}} \ --protocol tcp --health-checks ilb-health

Esse serviço vincula a verificação de integridade ao grupo de instâncias.

Adicionar o grupo de instâncias ao serviço de back-end

3. Execute o seguinte comando para conectar o grupo de instâncias de back-end ao serviço de back-end "prime-service". Isso informa ao balanceador de carga quais máquinas ele precisa gerenciar:

gcloud compute backend-services add-backend prime-service \ --instance-group backend --instance-group-zone={{{project_0.default_zone | ZONE }}} \ --region={{{project_0.default_region | REGION}}}

Criar a regra de encaminhamento

4. Por fim, execute o seguinte comando para criar uma regra de encaminhamento chamada prime-lb com um IP estático de :

gcloud compute forwarding-rules create prime-lb \ --load-balancing-scheme internal \ --ports 80 --network default \ --region={{{project_0.default_region | REGION}}} --address {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}} \ --backend-service prime-service

O serviço interno de "cálculo de números primos" está totalmente configurado e pronto para ser consultado pelo endereço IP interno.

Clique em Verificar meu progresso para saber se você está no caminho certo neste laboratório.

Configurar o balanceador de carga interno

Tarefa 4: testar o balanceador de carga

Esta etapa é fundamental para confirmar se o balanceador de carga de aplicativo interno está direcionando o tráfego corretamente aos serviços de back-end. Isso prova que outros aplicativos internos agora podem acessar seu serviço de forma confiável por um único endereço IP estável, garantindo a operação contínua.

Para testar o balanceador de carga, crie uma instância de VM na mesma rede do balanceador de carga de aplicativo interno. Ele só pode ser acessado na rede de nuvem privada, e não diretamente do Cloud Shell, que fica fora dessa rede específica.

1. No Cloud Shell, execute o seguinte comando gcloud para criar uma instância de teste simples:

gcloud compute instances create testinstance \ --machine-type=e2-standard-2 --zone {{{project_0.default_zone | ZONE }}}

2. Depois, execute o seguinte comando para usar SSH nela:

gcloud compute ssh testinstance --zone {{{project_0.default_zone | ZONE }}}

Se for solicitado, digite Y e pressione Enter duas vezes para prosseguir.

Consultar o balanceador de carga

3. Na instância de teste, execute os seguintes comandos curl para perguntar ao endereço IP do balanceador de carga de aplicativo interno se alguns números são primos:

curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/2 curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/4 curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/5

A resposta mostra "True" ou "False" ao lado da linha de comando.

Resposta:

user@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/2 Trueuser@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/4 Falseuser@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/5 Trueuser@testinstance:~$ exit

Perceba que 2 e 5 são identificados corretamente como números primos, mas 4 não é. Isso confirma que o balanceador de carga de aplicativo interno está funcionando corretamente. Ele recebeu as solicitações e as encaminhou para uma das VMs de "cálculo de números primos" de back-end.

O serviço respondeu corretamente: 2 e 5 são números primos, mas 4 não é.

4. Execute o seguinte comando para sair da instância de teste:

exit

5. Depois, execute o seguinte comando para excluí-la, já que ela não é mais necessária:

gcloud compute instances delete testinstance --zone={{{project_0.default_zone | ZONE }}}

6. Digite Y para confirmar a exclusão.

Tarefa 5: criar um servidor da Web voltado ao público

Agora você pode ver como um aplicativo voltado ao público, como um site, pode aproveitar os serviços internos.

Nesta tarefa, você vai criar um servidor da Web público que usa o serviço interno "calculadora de números primos" (pelo balanceador de carga de aplicativo interno) para mostrar uma matriz de números primos.

1. Primeiro execute o seguinte comando para criar o script de inicialização para esse "front-end" voltado ao público no diretório principal:

touch ~/frontend.sh

2. O editor de código ainda vai estar aberto. Se não estiver, selecione o Editor de código no shell para iniciá-lo:

Depois de alguns segundos, o espaço de trabalho será aberto.

3. Selecione o arquivo frontend.sh no painel "Buscador de arquivos".

4. Agora, adicione o seguinte script ao editor:

sudo chmod -R 777 /usr/local/sbin/ sudo cat << EOF > /usr/local/sbin/getprimes.py import urllib.request from multiprocessing.dummy import Pool as ThreadPool import http.server PREFIX="http://{{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/" #HTTP Load Balancer def get_url(number): return urllib.request.urlopen(PREFIX+str(number)).read().decode('utf-8') class myHandler(http.server.BaseHTTPRequestHandler): def do_GET(s): s.send_response(200) s.send_header("Content-type", "text/html") s.end_headers() i = int(s.path[1:]) if (len(s.path)>1) else 1 s.wfile.write("<html><body><table>".encode('utf-8')) pool = ThreadPool(10) results = pool.map(get_url,range(i,i+100)) for x in range(0,100): if not (x % 10): s.wfile.write("<tr>".encode('utf-8')) if results[x]=="True": s.wfile.write("<td bgcolor='#00ff00'>".encode('utf-8')) else: s.wfile.write("<td bgcolor='#ff0000'>".encode('utf-8')) s.wfile.write(str(x+i).encode('utf-8')+"</td> ".encode('utf-8')) if not ((x+1) % 10): s.wfile.write("</tr>".encode('utf-8')) s.wfile.write("</table></body></html>".encode('utf-8')) http.server.HTTPServer(("",80),myHandler).serve_forever() EOF nohup python3 /usr/local/sbin/getprimes.py >/dev/null 2>&1 &

5. Clique em Arquivo > Salvar, mas não feche o arquivo.

   Como antes, peça ao Gemini Code Assist para explicar o script de inicialização de um servidor da Web público para um membro da equipe.

6. Com o arquivo frontend.sh aberto e o Gemini Code Assist ativado no ambiente de desenvolvimento integrado, observe a presença do ícone no canto superior direito do editor.

7. Clique no ícone Gemini Code Assist: Ações Inteligentes e selecione Explique isto.

8. O Gemini Code Assist abre um painel de chat com o comando Explicar isto preenchido. Na caixa de texto inline do chat do Code Assist, substitua o comando preenchido previamente pelo seguinte e clique em Enviar:

Você é um desenvolvedor de aplicativos na Cymbal AI. Um novo membro da equipe precisa de ajuda para entender esse script de inicialização, que é usado para executar um servidor da Web público escrito no arquivo Python getprimes.py. Explique o script frontend.sh em detalhes. Mostre em detalhes os principais componentes, os comandos usados e a função deles no script. Para as melhorias sugeridas, não faça alterações no conteúdo do arquivo.

Uma explicação detalhada do script de inicialização frontend.sh usado para executar um servidor da Web público aparece no chat do Gemini Code Assist.

Criar a instância de front-end

9. No terminal do Cloud Shell, execute o seguinte código para criar uma instância chamada frontend que executa este servidor da Web:

gcloud compute instances create frontend --zone={{{project_0.default_zone | ZONE }}} \ --metadata-from-file startup-script=frontend.sh \ --tags frontend --machine-type=e2-standard-2

Abrir o firewall para o front-end

10. Como esse é um servidor público, execute o seguinte comando para abrir o firewall dele e permitir o tráfego de qualquer lugar da Internet (0.0.0.0/0) na porta 80:

gcloud compute firewall-rules create http2 --network default --allow=tcp:80 \ --source-ranges 0.0.0.0/0 --target-tags frontend

11. No Menu de navegação, clique em Compute Engine > Instâncias de VM. Atualize o navegador se a instância frontend não aparecer.

12. Abra o IP externo do front-end no navegador:

Uma matriz como esta vai aparecer, mostrando todos os números primos até 100 em verde:

13. Tente adicionar um número ao caminho, como http://your-ip/10000, para ver todos os números primos a partir desse número.

Observação: além de não calcular os números primos de forma eficaz, o exemplo de script de inicialização. não tem algoritmos de detecção ou correção de erros. Adicionar números grandes ao caminho faz o serviço chegar ao tempo limite.

Clique em Verificar meu progresso para saber se você está no caminho certo neste laboratório.

Criar um servidor da Web voltado ao público

Parabéns!

Você criou um serviço interno confiável usando o balanceador de carga de aplicativo interno do Google Cloud com a ajuda do Gemini Code Assist e demonstrou como um aplicativo público pode utilizar esse serviço com segurança.

Próximas etapas / Saiba mais

• Leia mais sobre os balanceadores de carga de aplicativo internos.
• Saiba mais sobre sub-redes.
• Publique perguntas e encontre respostas no Stack Overflow com a tag google-compute-engine ou google-cloud-platform.

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 22 de agosto de 2025

Laboratório testado em 22 de agosto 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.