arrow_back

Como implantar, escalonar e atualizar um site no Google Kubernetes Engine

Como implantar, escalonar e atualizar um site no Google Kubernetes Engine

1 hora 30 minutos 1 crédito

GSP663

Laboratórios autoguiados do Google Cloud

Visão geral

Manter sites e aplicativos em operação não é uma tarefa simples. Erros inesperados acontecem, servidores falham, e o aumento de demanda exige mais recursos. Além disso, fazer alterações sem causar inatividade é difícil e estressante. Existe uma ferramenta que pode ajudar você com essas tarefas e até mesmo automatizá-las. No Kubernetes, fica mais fácil cuidar de tudo isso.

Neste laboratório, você será o desenvolvedor da empresa fictícia Fancy Store, que está gerenciando um site de comércio eletrônico. Devido a problemas de escalonamento e interrupções, você precisa implantar um aplicativo no Google Kubernetes Engine (GKE).

A ordem das tarefas reflete uma experiência comum de desenvolvedor de nuvem:

  1. Criar um cluster do GKE

  2. Criar um contêiner do Docker

  3. Implantar o contêiner no GKE

  4. Expor o contêiner por meio de um serviço

  5. Escalonar o contêiner para diversas réplicas

  6. Modificar o site

  7. Lançar uma nova versão sem inatividade

Diagrama da arquitetura

ddba666bd2b02d0d.png

O que você aprenderá

  • Como criar um cluster do Google Kubernetes Engine

  • Como criar uma imagem do Docker

  • Como implantar imagens do Docker no Kubernetes

  • Como escalonar um aplicativo no Kubernetes

  • Como realizar uma atualização gradual no Kubernetes

Pré-requisitos

Configuração

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 ficarão disponíveis.

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

O que é necessário

Para fazer este laboratório, você precisa ter:

  • acesso a um navegador de Internet padrão (recomendamos o Chrome);
  • tempo para concluir as atividades.

Observação: não use seu projeto ou sua conta do Google Cloud neste laboratório.

Observação: se estiver usando um dispositivo Chrome OS, abra uma janela anônima para executar o laboratório.

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. Ícone do menu de navegação

Ative o Google Cloud Shell

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

  1. No Console do GCP, na barra de ferramentas superior direita, clique no botão Abrir o Cloud Shell.

    Ícone do Cloud Shell

  2. Clique em Continue (continuar):

    cloudshell_continue

Demora alguns minutos para provisionar e conectar-se ao ambiente. Quando você está conectado, você já está autenticado e o projeto é definido como seu PROJECT_ID . Por exemplo:

Terminal do Cloud Shell

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

É possível listar o nome da conta ativa com este comando:

gcloud auth list

Saída:

ACTIVE: *
ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net
To set the active account, run:
    $ gcloud config set account `ACCOUNT`
	

É possível listar o ID de projeto com este comando:

gcloud config list project
	

Saída:

[core]
project = <project_ID>
	

Exemplo de saída:

[core]
project = qwiklabs-gcp-44776a13dea667a6
	

Defina a zona padrão e a configuração do projeto:

gcloud config set compute/zone us-central1-f

Saiba mais em Documentação de regiões e zonas.

Crie um cluster do GKE

Você precisa de um cluster do Kubernetes para implantar um site. Confirme que as APIs necessárias estão ativadas.

Execute o comando a seguir para ativar a API do Container Registry:

gcloud services enable container.googleapis.com

Agora você já pode criar um cluster.

Execute o código abaixo para criar um cluster do GKE chamado fancy-cluster com 3 nós:

gcloud container clusters create fancy-cluster --num-nodes 3

A criação do cluster levará alguns minutos.

Agora execute este comando para ver as três instâncias da VM de worker do cluster:

gcloud compute instances list

Saída:

NAME                                          ZONE        MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
gke-fancy-cluster-default-pool-ad92506d-1ng3  us-east4-a  n1-standard-1               10.150.0.7   XX.XX.XX.XX    RUNNING
gke-fancy-cluster-default-pool-ad92506d-4fvq  us-east4-a  n1-standard-1               10.150.0.5   XX.XX.XX.XX    RUNNING
gke-fancy-cluster-default-pool-ad92506d-4zs3  us-east4-a  n1-standard-1               10.150.0.6   XX.XX.XX.XX    RUNNING

Encontre seu cluster do Kubernetes e as informações relacionadas no Console do Google Cloud. Clique no Menu de navegação, role para baixo até Kubernetes Engine e clique em Clusters.

795c794b03c5d2b0.png

O cluster chamado fancy-cluster deve aparecer aqui.

6b394dfb8a6031f2.png

Parabéns! Você acabou de criar seu primeiro cluster do Kubernetes.

Clique em Verificar meu progresso para conferir o objetivo. Crie um cluster do GKE

Clone o repositório de origem

Como o site já existe, você só precisa clonar a origem e já pode se concentrar na criação de imagens do Docker e na implantação no GKE.

Execute os comandos a seguir para clonar o repositório do Git na instância do Cloud Shell:

cd ~
git clone https://github.com/googlecodelabs/monolith-to-microservices.git

Mude para o diretório apropriado. Instale as dependências do NodeJS para testar o aplicativo antes da implantação:

cd ~/monolith-to-microservices
./setup.sh

Aguarde a execução do script terminar.

Verifique se você está executando o Cloud Shell com a versão mais recente do npm:

nvm install --lts

Mude para o diretório apropriado e teste o aplicativo. Execute o comando a seguir para iniciar o servidor da Web:

cd ~/monolith-to-microservices/monolith
npm start

Saída:

Monolith listening on port 8080!

Para ver o aplicativo, clique no ícone de visualização da Web e selecione Visualizar na porta 8080:

CloudShell_web_preview.png

Você verá Fancy Store em ação em uma nova janela.

f075aec979aaffc8.png

Deixe esta guia aberta, porque você voltará para ela mais tarde no laboratório.

Para interromper o processo do servidor da Web, pressione CTRL+C no Cloud Shell.

Crie o contêiner do Docker com o Cloud Build

Agora que os arquivos de origem estão prontos, é hora de colocar o aplicativo no Docker.

O método mais comum seria criar um contêiner do Docker e enviá-lo para um registro, onde a imagem é armazenada e pode ser extraída pelo GKE. Existe um jeito mais fácil: crie o contêiner do Docker no Cloud Build e envie a imagem para o Container Registry com um único comando. Apenas com esse comando, você cria e move a imagem para o Container Registry. Para ver o processo manual de criação e envio de um arquivo do Docker, clique aqui.

O Google Cloud Build compacta e envia os arquivos do diretório para um bucket do Google Cloud Storage. Todos os arquivos do bucket e o Dockerfile no mesmo diretório serão usados para executar o processo de compilação no Docker. Como a sinalização --tag foi especificada com o host como gcr.io para a imagem do Docker, a imagem do Docker resultante será enviada por push para o Google Cloud Container Registry.

Para verificar se a API do Cloud Build está ativada, execute o seguinte comando:

gcloud services enable cloudbuild.googleapis.com

Execute este comando para iniciar o processo de criação:

cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 .

O processo levará alguns minutos.

O terminal mostrará uma saída semelhante à seguinte:

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID                                    CREATE_TIME                DURATION  SOURCE                                                                                  IMAGES                              STATUS
1ae295d9-63cb-482c-959b-bc52e9644d53  2019-08-29T01:56:35+00:00  33S       gs://<PROJECT_ID>_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz  gcr.io/<PROJECT_ID>/monolith:1.0.0  SUCCESS

Para ver o histórico de versões ou acompanhar o processo em tempo real, clique no Menu de navegação, role para baixo até a seção "Ferramentas" e clique em Cloud Build > Histórico. Aqui você encontra uma lista das versões anteriores.

181cf510d755b855.png

Clique no nome da versão para ver os detalhes, inclusive a saída do registro.

Opcional: Na página de detalhes da compilação, clique em Resumo de criação > Detalhes da execução > Nome da imagem na seção de informações da compilação para ver a imagem do contêiner:

6e88ed1643dfe629.png

Clique em Verificar meu progresso para conferir o objetivo. Crie o contêiner do Docker com o Cloud Build

Implante o contêiner no GKE

Agora que você já colocou o site em um contêiner e enviou o contêiner para o Google Container Registry, é hora de implantá-lo no Kubernetes.

Para implantar e gerenciar aplicativos em um Cluster do GKE, você precisa se comunicar com o sistema de gerenciamento de clusters do Kubernetes. Geralmente a ferramenta de linha de comando kubectl é usada para isso.

O Kubernetes representa aplicativos como pods, que são unidades com um contêiner ou um grupo de contêineres estreitamente associados. O pod é a menor unidade implantável no Kubernetes. Neste laboratório, cada pod tem apenas o contêiner monolith que você criou.

Para implantar seu aplicativo, crie um recurso de implantação. Esse recurso gerencia diversas cópias do aplicativo, chamadas de réplicas. Ele programa as réplicas para serem executadas em nós individuais do cluster. Neste laboratório, o recurso de implantação executará apenas um pod do aplicativo. Para isso, o recurso de implantação cria um ReplicaSet. O ReplicaSet é responsável por garantir que as réplicas especificadas estejam sempre em execução.

Com o comando kubectl create deployment, que você usará em seguida, o Kubernetes cria um recurso de implantação chamado monolith no cluster com 1 réplica.

Execute o comando a seguir para implantar o aplicativo:

kubectl create deployment monolith --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0

Clique em Verificar meu progresso para conferir o objetivo. Implante o contêiner no GKE

Verifique a implantação

Para confirmar que a implantação foi criada corretamente, execute o seguinte comando:

kubectl get all

Execute o comando novamente até o status do pod mudar para "Em execução".

Saída:

NAME                            READY   STATUS    RESTARTS   AGE
pod/monolith-7d8bc7bf68-htm7z   1/1     Running   0          6m21s
NAME                 TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.27.240.1   <none>        443/TCP   24h
NAME                       DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/monolith   1         1         1            1           20m
NAME                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/monolith-7d8bc7bf68   1         1         1       20m

Esta saída apresenta várias informações:

  • A implantação atual
  • O ReplicaSet com a quantidade desejada de apenas 1 pod
  • O pod em execução

Parece que tudo foi criado corretamente.

Opcional: também é possível executar comandos para cada implantação:

# Show pods
kubectl get pods
# Show deployments
kubectl get deployments
# Show replica sets
kubectl get rs
#You can also combine them
kubectl get pods,deployments

Para conhecer todos os benefícios do Kubernetes, simule uma falha no servidor excluindo um pod e veja o que acontece.

Use o nome de um pod do comando anterior e execute o seguinte para excluí-lo:

kubectl delete pod/<POD_NAME>

É possível acompanhar a exclusão na página Cargas de trabalho, basta clicar no nome da carga de trabalho. É muito rápido.

Você também precisa ter bastante agilidade para executar get all de novo e ver dois pods: um sendo encerrado e outro sendo criado ou executado:

kubectl get all

Saída:

NAME                            READY   STATUS        RESTARTS   AGE
pod/monolith-7d8bc7bf68-2bxts   1/1     Running       0          4s
pod/monolith-7d8bc7bf68-htm7z   1/1     Terminating   0          9m35s
NAME                 TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.27.240.1   <none>        443/TCP   24h
NAME                       DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/monolith   1         1         1            1           24m
NAME                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/monolith-7d8bc7bf68   1         1         1       24m

Por que isso aconteceu? O ReplicaSet notou que o pod estava sendo encerrado e acionou um novo para manter a quantidade de réplicas escolhida. Mais adiante no laboratório, você aprenderá a escalonar horizontalmente para garantir várias instâncias em execução. Dessa forma, você evita a inatividade se algum pod falhar.

Exponha a implantação do GKE

Você implantou seu aplicativo no GKE, mas não é possível acessá-lo de fora do cluster. Por padrão, os contêineres executados no GKE não podem ser acessados pela Internet porque não têm endereços IP externos. Exponha explicitamente o aplicativo ao tráfego da Internet usando o recurso Serviço. Esse serviço dá suporte de rede e IP aos pods do seu aplicativo. O GKE cria um IP externo e um balanceador de carga para o aplicativo.

Execute o comando a seguir para expor o site à Internet:

kubectl expose deployment monolith --type=LoadBalancer --port 80 --target-port 8080

Como acessar o serviço

O GKE atribui o endereço IP externo ao serviço, não à implantação. Se você quer descobrir o IP externo provisionado pelo GKE para o aplicativo, inspecione o serviço com o comando kubectl get service:

kubectl get service

Saída:

NAME         CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
monolith     10.3.251.122    203.0.113.0     80:30877/TCP     3d

Execute o comando novamente até que o serviço tenha um endereço IP externo.

Depois de definir o endereço IP externo do seu aplicativo, copie e cole esse IP no navegador para acessar o URL (como http://203.0.113.0) e verificar se é possível acessar o aplicativo.

Você verá o mesmo site que testou antes. Agora seu site está sendo executado integralmente no Kubernetes.

Clique em Verificar meu progresso para conferir o objetivo. Exponha a implantação do GKE

Escalone a implantação do GKE

Agora que seu aplicativo está sendo executado no GKE e disponível na Internet, imagine que ele ficou muito famoso. Você precisa escalonar seu aplicativo para diversas instâncias e garantir que ele possa lidar com o aumento do tráfego. A seguir você aprenderá a escalonar o aplicativo para até três réplicas.

No Cloud Shell, escalone sua implantação para até três réplicas com o seguinte comando:

kubectl scale deployment monolith --replicas=3

Verifique se a implantação foi escalonada corretamente:

kubectl get all

Saída:

NAME                            READY   STATUS    RESTARTS   AGE
pod/monolith-7d8bc7bf68-2bxts   1/1     Running   0          36m
pod/monolith-7d8bc7bf68-7ds7q   1/1     Running   0          45s
pod/monolith-7d8bc7bf68-c5kxk   1/1     Running   0          45s
NAME                 TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)        AGE
service/kubernetes   ClusterIP      10.27.240.1    <none>         443/TCP        25h
service/monolith     LoadBalancer   10.27.253.64   XX.XX.XX.XX   80:32050/TCP   6m7s
NAME                       DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/monolith   3         3         3            3           61m
NAME                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/monolith-7d8bc7bf68   3         3         3       61m

Você verá três instâncias do seu pod em execução. A implantação e a réplica agora refletem a quantidade escolhida de três pods.

Clique em Verificar meu progresso para conferir o objetivo. Escalone a implantação do GKE

Faça alterações no site

Cenário: sua equipe de marketing precisa que você mude a página inicial do site. Ela quer que a página inclua mais informações sobre a empresa e os produtos vendidos.

Tarefa: para atender ao pedido da equipe de marketing, você adicionará um texto à página inicial. Parece que um dos desenvolvedores já criou as alterações. O nome do arquivo atualizado é index.js.new. Você só precisa copiar esse arquivo para index.js, e as mudanças aparecerão na página. Siga as instruções abaixo para fazer as alterações necessárias.

Execute os comandos a seguir para copiar o arquivo atualizado no arquivo com o nome correto:

cd ~/monolith-to-microservices/react-app/src/pages/Home
mv index.js.new index.js

Imprima o conteúdo para verificar as alterações:

cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js

O código resultante deve ser semelhante ao seguinte:

/*
Copyright 2019 Google LLC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
    https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
import React from "react";
import { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
  root: {
    flexGrow: 1
  },
  paper: {
    width: "800px",
    margin: "0 auto",
    padding: theme.spacing(3, 2)
  }
}));
export default function Home() {
  const classes = useStyles();
  return (
    <div className={classes.root}>
      <Paper className={classes.paper}>
        <Typography variant="h5">
          Fancy Fashion &amp; Style Online
        </Typography>
        <br />
        <Typography variant="body1">
          Tired of mainstream fashion ideas, popular trends and societal norms?
          This line of lifestyle products will help you catch up with the Fancy trend and express your personal style.
          Start shopping Fancy items now!
        </Typography>
      </Paper>
    </div>
  );
}

Os componentes do React foram atualizados, mas o aplicativo React precisa ser criado para gerar os arquivos estáticos.

Execute o comando a seguir para criar o aplicativo React e copiá-lo no diretório público monolith:

cd ~/monolith-to-microservices/react-app
npm run build:monolith

Agora que o código foi atualizado, é necessário recriar o contêiner do Docker e publicá-lo no Google Cloud Container Registry. O comando é o mesmo que você usou antes, mas com o rótulo da nova versão.

Execute o comando abaixo para acionar o Cloud Build de novo com a imagem atualizada (versão 2.0.0):

cd ~/monolith-to-microservices/monolith
gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .

Na próxima seção você usará essa imagem para atualizar o aplicativo sem inatividade.

Clique em Verificar meu progresso para conferir o objetivo. Faça alterações no site

Atualize o site sem inatividade

As alterações foram feitas, e a equipe de marketing adorou a nova versão. É hora de atualizar o site sem interrupção para os usuários.

O mecanismo de atualização gradual do GKE garante que o aplicativo permaneça ativo e disponível, até mesmo enquanto o sistema substitui instâncias da imagem de contêiner antiga por todas as réplicas em execução.

Solicite que o Kubernetes atualize a imagem da implantação para uma nova versão com o seguinte comando:

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0

Verifique a implantação

Para validar a atualização da implantação, execute o seguinte comando:

kubectl get pods

Saída:

NAME                        READY   STATUS              RESTARTS   AGE
monolith-584fbc994b-4hj68   1/1     Terminating         0          60m
monolith-584fbc994b-fpwdw   1/1     Running             0          60m
monolith-584fbc994b-xsk8s   1/1     Terminating         0          60m
monolith-75f4cf58d5-24cq8   1/1     Running             0          3s
monolith-75f4cf58d5-rfj8r   1/1     Running             0          5s
monolith-75f4cf58d5-xm44v   0/1     ContainerCreating   0          1s

Aqui você verá três novos pods sendo criados e os pods antigos sendo desativados. É possível identificar os pods novos e os antigos pela idade deles. Depois você verá apenas os três pods atualizados.

Para verificar as alterações, volte à guia do aplicativo no navegador da Web e atualize a página. Veja que o aplicativo foi atualizado.

O site agora mostra o texto que você acabou de incluir no componente da página inicial.

55324dbf3ec7f17f.png

Clique em Verificar meu progresso para conferir o objetivo. Atualize o site sem tempo de inatividade

Limpeza

Embora todos os recursos sejam excluídos após a conclusão deste laboratório, é útil saber como fazer isso no seu ambiente.

Exclua o repositório do Git:

cd ~
rm -rf monolith-to-microservices

Exclua imagens do Google Container Registry:

# Delete the container image for version 1.0.0 of the monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --quiet
# Delete the container image for version 2.0.0 of the monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 --quiet

Exclua os artefatos do Google Cloud Build no Google Cloud Storage:

# The following command will take all source archives from all builds and delete them from cloud storage
# Run this command to print all sources:
# gcloud builds list | awk 'NR > 1 {print $4}'
gcloud builds list | grep 'SOURCE' | cut -d ' ' -f2 | while read line; do gsutil rm $line; done

Exclua o serviço GKE:

kubectl delete service monolith
kubectl delete deployment monolith

Exclua o cluster do GKE:

gcloud container clusters delete fancy-cluster

Digite "y" para confirmar a ação. Esse comando pode demorar alguns minutos para ser concluído.

Parabéns!

Você implantou, escalonou e atualizou corretamente seu site no GKE. Agora você já sabe usar o Docker e o Kubernetes.

completion_badge_Website_on_Google_Cloud-135.png

Termine a Quest

Este laboratório autoguiado faz parte da Quest do Qwiklabs Website on Google Cloud. Quest é uma série de laboratórios relacionados que formam um programa de aprendizado. Caso você já tenha feito este laboratório, inscreva-se nesta Quest para ganhar os créditos de conclusão imediatamente. Veja outras Quests do Qwiklabs.

Procurando um laboratório prático com desafio para demonstrar suas habilidades e validar seu conhecimento? Quando terminar a Quest, faça este laboratório com desafio adicional para receber um selo digital exclusivo do Google Cloud.

Build_a_Website_on_Google_Cloud_Skill_WBG-135.png

Comece o próximo laboratório

Continue aprendendo com Como migrar um site monolítico para microsserviços no Google Kubernetes Engine ou confira estas sugestões:

Próximas etapas / Saiba mais

Manual atualizado em 11 de fevereiro de 2022
Laboratório testado em 11 de fevereiro de 2022

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