GSP053

Informações gerais

Regularmente, as práticas de DevOps para gestão de cenários de implantação de aplicativos consistem em várias etapas, por exemplo: Implantação Contínua, Implantações Azul-verde ou Implantações Canário, entre outras. Este laboratório ensina a gerenciar contêineres em escala e criar esses cenários comuns, em que várias implantações heterogêneas são usadas.

Objetivos

Neste laboratório, você vai aprender a:

• Usar a ferramenta kubectl
• Criar arquivos yaml de implantação
• Iniciar, atualizar e escalonar implantações
• Atualizar implantações e aprender sobre estilos de implantação

Pré-requisitos

Para maximizar seu aprendizado neste laboratório, recomendamos o seguinte:

• Fazer estes laboratórios do Google Cloud Skills Boost:
  • Introdução ao Docker
  • Nó do Hello Kubernetes
• Saber administrar o sistema Linux
• Entender os conceitos de implantação contínua da teoria de DevOps

Introdução às implantações

Em geral, as implantações heterogêneas envolvem a conexão de dois ou mais ambientes ou regiões com infraestruturas diferentes para atender a uma necessidade técnica ou operacional específica. Elas podem ser chamadas de "híbridas", "multicloud" ou "públicas-particulares", dependendo das características específicas da implantação.

As implantações heterogêneas usadas neste laboratório abrangem regiões dentro de um único ambiente de nuvem, de vários ambientes de nuvem pública (multicloud) ou uma combinação de ambientes de nuvens locais e públicas (híbridos ou públicos-particulares).

Podem surgir alguns desafios, tanto comerciais como técnicos, durante implantações limitadas a um único ambiente ou região:

• Recursos esgotados: em qualquer ambiente único, particularmente nos locais, talvez os recursos de computação, de rede e de armazenamento não atendam às suas necessidades de produção.
• Alcance geográfico limitado: as implantações em um único ambiente exigem o acesso de pessoas em regiões geográficas distantes. O tráfego delas pode viajar ao redor do mundo até um local central.
• Disponibilidade limitada: os padrões de tráfego na escala da Web desafiam os aplicativos a permanecerem resilientes e tolerantes a falhas.
• Dependência de fornecedores específicos: abstrações de plataforma e infraestrutura de fornecedores podem impedir a portabilidade dos aplicativos.
• Recursos inflexíveis: seus recursos podem estar limitados a um determinado conjunto de soluções de computação, armazenamento ou rede.

Com as implantações heterogêneas, é possível superar esses desafios, mas elas precisam de uma arquitetura com processos e procedimentos programáticos e deterministas. Os procedimentos de implantação únicos ou ad-hoc podem deixar os processos frágeis e intolerantes a falhas. Além disso, os processos ad-hoc podem perder dados ou tráfego. Uma boa implantação precisa ter um processo que possa ser repetido, com métodos comprovados de gestão de provisionamento, configuração e manutenção.

Três cenários comuns de implantação heterogênea são:

• Implantações multicloud
• Interfaceamento de dados locais
• Processos de integração contínua/entrega contínua (CI/CD)

Os exercícios a seguir colocam em prática alguns casos de uso comuns de implantações heterogêneas com abordagens bem arquitetadas, usando o Kubernetes e outros recursos de infraestrutura.

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.

Definir a zona

Execute o comando abaixo para definir sua zona de trabalho do Google Cloud, substituindo a zona local por :

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

Vamos usar um exemplo de código neste laboratório

1. Acesse o exemplo de código no bucket do laboratório para criar e executar contêineres e implantações:

gcloud storage cp -r gs://spls/gsp053/kubernetes . cd kubernetes

2. Crie um cluster com três nós (esse processo vai levar alguns minutos):

gcloud container clusters create bootcamp \ --machine-type e2-small \ --num-nodes 3 \ --scopes "https://www.googleapis.com/auth/projecthosting,storage-rw"

Tarefa 1: identificar o objeto de implantação

Para começar, confira o objeto de implantação.

1. O comando explain na kubectl inclui informações sobre o objeto de implantação:

kubectl explain deployment

2. Também podemos ver todos os campos que estão usando a opção --recursive.

kubectl explain deployment --recursive

3. O comando "explain" pode ser usado durante o laboratório para entender a estrutura de um objeto de implantação e o que cada campo faz.

kubectl explain deployment.metadata.name

Tarefa 2: criar uma implantação

1. Crie a implantação fortune-app. Examine o arquivo de configuração da implantação:

cat deployments/fortune-app-blue.yaml

Saída:

# orchestrate-with-kubernetes/kubernetes/deployments/fortune-app-blue.yaml apiVersion: apps/v1 kind: Deployment metadata: name: fortune-app-blue spec: replicas: 3 selector: matchLabels: app: fortune-app template: metadata: labels: app: fortune-app track: stable version: "1.0.0" spec: containers: - name: fortune-app # The new, centralized image path image: "us-central1-docker.pkg.dev/qwiklabs-resources/spl-lab-apps/fortune-service:1.0.0" ports: - name: http containerPort: 8080 ...

Observe que a implantação cria três réplicas e usa a versão 1.0.0 do contêiner fortune-service.

2. Crie seu objeto de implantação usando kubectl create:

kubectl create -f deployments/fortune-app-blue.yaml

3. Depois de criar a implantação, confirme se ela foi gerada:

kubectl get deployments

4. Depois que a implantação for criada, o Kubernetes vai gerar um ReplicaSet para ela. É possível confirmar que um ReplicaSet foi criado para a implantação com esse comando:

kubectl get replicasets

O ReplicaSet deve ter um nome semelhante a fortune-app-blue-xxxxxxx

5. Confira os pods criados durante a implantação.

kubectl get pods

6. Agora, crie um serviço para expor a implantação do fortune-app externamente.

kubectl create -f services/fortune-app.yaml

7. Interaja com o fortune-app capturando o IP externo e usando o comando curl no endpoint /version:

kubectl get services frontend Observação: pode levar alguns segundos até que o campo "External-IP" seja preenchido pelo serviço. Isso é normal. Basta executar o comando acima de novo, depois de alguns segundos, até o campo ser preenchido. curl http://<EXTERNAL-IP>/version

Você vai receber uma resposta JSON indicando {"version":"1.0.0"}.

8. Use o recurso de modelo de saída da kubectl para usar "curl" e um único comando compacto:

curl http://`kubectl get svc fortune-app -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

Testar a tarefa concluída

Clique em Verificar meu progresso para conferir seu andamento no laboratório. Se o cluster do Kubernetes e a implantação e o serviço do fortune-app tiverem sido criados corretamente, você vai receber uma pontuação de avaliação.

Criar um cluster e implantações (fortune-app) do Kubernetes

Escalonar uma implantação

Agora que a implantação foi criada, ela pode ser escalonada. Faça isso atualizando o campo spec.replicas.

1. O jeito mais fácil de atualizar o campo "replicas" é usando o comando kubectl scale:

kubectl scale deployment fortune-app-blue --replicas=5 Observação: pode levar mais ou menos um minuto até que todos os novos pods sejam iniciados.

2. Confirme que agora há cinco pods fortune-app-blue em execução:

kubectl get pods | grep fortune-app-blue | wc -l

3. Agora reduza a escala do aplicativo:

kubectl scale deployment fortune-app-blue --replicas=3

4. Confirme novamente se o número de pods está correto:

kubectl get pods | grep fortune-app-blue | wc -l

Agora você conhece as implantações do Kubernetes e sabe como gerenciar e escalonar um grupo de pods.

Tarefa 3: atualização gradual

As implantações permitem atualizar as imagens para uma nova versão usando um mecanismo de atualização gradual.

Acionar uma atualização gradual

1. Para acionar uma atualização contínua, basta aplicar a configuração da Implantação Verde. O Kubernetes é inteligente o suficiente para identificar a implantação atual (fortune-app-blue) e vai "transferir" as mudanças do novo arquivo para ela.

kubectl edit deployment fortune-app-blue

2. No editor, encontre a linha image e mude a tag de versão de 1.0.0 para 2.0.0. Para editar o arquivo, pressione i no teclado para entrar no "modo de inserção".

• Primeiro, mude a tag da imagem:

  • Encontre esta linha: image: "us-central1-docker.pkg.dev/qwiklabs-resources/spl-lab-apps/fortune-service:1.0.0"
  • E mude para: image: "us-central1-docker.pkg.dev/qwiklabs-resources/spl-lab-apps/fortune-service:2.0.0"

• Em seguida, atualize a variável de ambiente:

  • Encontre a seção env e a variável APP_VERSION.
  • Mude value: "1.0.0" para value: "2.0.0"

3. Salve e feche o editor. Para fazer isso, pressione Esc, digite :wq e pressione Enter. Isso vai acionar a atualização gradual na implantação correta e fazer o devido registro do histórico dela. Isso vai acionar a atualização gradual na implantação correta e fazer o devido registro do histórico dela.

4. Confira o novo ReplicaSet criado pelo Kubernetes:

kubectl get replicaset

5. Uma nova entrada vai aparecer no histórico de lançamentos:

kubectl rollout history deployment/fortune-app-blue

Pausar uma atualização gradual

1. Execute o seguinte comando para pausar o lançamento:

kubectl rollout pause deployment/fortune-app-blue

2. Verifique o estado atual do lançamento:

kubectl rollout status deployment/fortune-app-blue Observação: o comando de status pode informar imediatamente "deployment "fortune-app-blue" successfully rolled out". Isso é esperado e indica que o comando de pausa foi bem-sucedido. Isso não significa que a atualização da versão foi concluída.

3. Verifique a versão de cada pod. Você vai ver uma mistura de pods 1.0.0 e 2.0.0, confirmando que a implantação foi pausada no meio do caminho.

for p in $(kubectl get pods -l app=fortune-app -o=jsonpath='{.items[*].metadata.name}'); do echo $p && curl -s http://$(kubectl get pod $p -o=jsonpath='{.status.podIP}')/version; echo; done

4. Pressione Ctrl+C para sair do loop.

Retomar uma atualização gradual

1. Continue o lançamento usando o comando resume:

kubectl rollout resume deployment/fortune-app-blue

2. Quando o lançamento estiver concluído, execute o comando status para mostrar o seguinte:

kubectl rollout status deployment/fortune-app-blue

Reverter uma atualização

Suponha que um bug tenha sido detectado na sua nova versão.

1. Faça a reversão usando o comando rollout:

kubectl rollout undo deployment/fortune-app-blue Observação: a reversão pode levar alguns instantes para ser concluída.

2. Verifique se todos os pods foram revertidos para a versão 1.0.0:

curl http://`kubectl get svc fortune-app -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

Ótimo! Você aprendeu a fazer uma atualização gradual para implantações do Kubernetes.

Tarefa 4: implantações Canário

Quando você quiser testar uma nova implantação em produção com um subgrupo de usuários, use uma Implantação Canário.

Criar uma Implantação Canário

1. Primeiro, crie uma Implantação Canário para a nova versão usando o arquivo fortune-app-canary.yaml:

cat deployments/fortune-app-canary.yaml

2. Agora crie a Implantação Canário:

kubectl create -f deployments/fortune-app-canary.yaml

3. Depois que a Implantação Canário for criada, você vai ter duas implantações. Verifique com este comando:

kubectl get deployments

O serviço fortune-app tem um seletor para app: fortune-app, que vai direcionar o tráfego aos pods nas duas implantações: fortune-app-blue (prod) e fortune-app-canary.

Verificar a Implantação Canário

1. É possível verificar a versão que está sendo veiculada fazendo solicitações ao serviço.

for i in {1..10}; do curl -s http://`kubectl get svc fortune-app -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version; echo; done

2. Execute esse comando várias vezes. Você verá que a maioria das solicitações é atendida pela versão 1.0.0, e um pequeno subconjunto é atendido pela versão 2.0.0.

Testar a tarefa concluída

Clique em Verificar meu progresso para conferir seu andamento no laboratório. Se a Implantação Canário tiver sido criada corretamente, a pontuação de avaliação será mostrada.

Implantação Canário

Tarefa 5: Implantações Azul-verde

Para Implantações Azul-verde, você vai criar duas implantações separadas e alternar o tráfego entre elas atualizando o seletor de serviço.

O serviço

1. Primeiro, atualize o serviço para apontar apenas para a versão "azul" (1.0.0).

kubectl apply -f services/fortune-app-blue-service.yaml

Atualização usando a Implantação Azul-verde

1. Agora, crie a nova Implantação Verde para a versão 2.0.0.

kubectl create -f deployments/fortune-app-green.yaml

2. Depois que a Implantação Verde for iniciada, verifique se a versão atual que está sendo veiculada ainda é a 1.0.0.

curl http://`kubectl get svc fortune-app -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

3. Agora, atualize o serviço apontando-o para a nova versão "verde":

kubectl apply -f services/fortune-app-green-service.yaml

4. Depois que o serviço for atualizado, a Implantação Verde será usada imediatamente. Agora, é possível verificar que a versão 2.0.0 está sempre sendo usada:

curl http://`kubectl get svc fortune-app -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

Reversão Azul-verde

1. Para reverter, basta reaplicar o manifesto de serviço para a Implantação Azul:

kubectl apply -f services/fortune-app-blue-service.yaml

2. A reversão vai ocorrer após a atualização do serviço. Verifique se a versão 1.0.0 está sendo usada:

curl http://`kubectl get svc fortune-app -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

Muito bom! Você conheceu as Implantações Azul-verde e aprendeu a implantar atualizações em aplicativos que precisam mudar versões de uma só vez.

Implantação Azul-verde

Parabéns!

Neste laboratório, você teve a oportunidade de trabalhar mais com a ferramenta de linha de comando kubectl e com vários estilos de configurações de implantação em arquivos YAML para iniciar, atualizar e escalonar suas implantações.

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 18 de agosto de 2025.

Laboratório testado em 18 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.