GSP053

Informações gerais

Regularmente, as práticas do Dev Ops usam várias implantações para gerenciar cenários de implantação de aplicativos, como a "Implantação contínua", as "Implantações azul-verde", as "Implantações canário", entre outras. Neste laboratório, apresentamos práticas de escalonamento e gerenciamento de contêineres para você criar esses cenários comuns em que várias implantações heterogêneas são usadas.

Objetivos

Neste laboratório, você vai:

• Ter experiências práticas com 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 que você:

• Faça estes laboratórios do Google Cloud Ensina:
  • Introdução ao Docker
  • Hello Node Kubernetes
• Tenha habilidades de administração do sistema Linux.
• Entenda a teoria de DevOps: conceitos de implantação contínua.

Introdução às implantações

Em geral, as implantações heterogêneas envolvem a conexão de dois ou mais ambientes ou regiões de infraestrutura diferentes para atender a uma necessidade técnica ou operacional específica. As implantações heterogêneas são chamadas de "híbridas", "de várias nuvens" 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 (várias nuvens) ou uma combinação de ambientes de nuvem locais e públicos (híbridos ou públicos-particulares).

Vários desafios comerciais e técnicos podem surgir em implantações limitadas a um único ambiente ou região:

• Recursos esgotados: em qualquer ambiente único, particularmente em ambientes 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 que pessoas geograficamente distantes umas das outras acessem uma implantação. 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 um fornecedor: a plataforma e as abstrações da infraestrutura no nível do fornecedor podem impedir a portabilidade dos aplicativos.
• Recursos inflexíveis: seus recursos podem estar limitados a um determinado conjunto de ofertas de computação, armazenamento ou rede.

As implantações heterogêneas ajudam a superar esses desafios, mas precisam ser projetadas com processos e procedimentos programáticos e deterministas. Os procedimentos de implantação únicos ou ad-hoc podem tornar as implantações ou os processos frágeis e intolerantes a falhas. Os processos ad-hoc podem perder dados ou tráfego. Os bons processos de implantação precisam ser repetíveis e usar abordagens comprovadas para gerenciar o provisionamento, a configuração e a manutenção.

Três cenários comuns de implantação heterogênea são: implantações de várias nuvens, dados locais à frente e processos de integração contínua/entrega contínua (CI/CD, na sigla em inglês).

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

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.

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 }}}

Receber um exemplo de código para este laboratório

1. Receba o exemplo de código para criar e executar contêineres e implantações:

gsutil -m cp -r gs://spls/gsp053/orchestrate-with-kubernetes . cd orchestrate-with-kubernetes/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: Saber mais sobre o objeto de implantação

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

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

kubectl explain deployment

2. Também podemos mostrar 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. Atualize o arquivo de configuração deployments/auth.yaml:

vi deployments/auth.yaml

2. Inicie o editor:

i

3. Altere image na seção de contêineres da implantação para o seguinte:

... containers: - name: auth image: "kelseyhightower/auth:1.0.0" ...

4. Salve o arquivo auth.yaml: pressione <Esc> e depois digite:

:wq

5. Pressione <Enter>. Agora, crie uma implantação simples. Examine o arquivo de configuração de implantação:

cat deployments/auth.yaml

Saída:

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

Observe como a implantação está criando uma réplica e usando a versão 1.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 alterando o número especificado no campo replicas.

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

kubectl create -f deployments/auth.yaml

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

kubectl get deployments

8. 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:

kubectl get replicasets

O ReplicaSet deve ter um nome semelhante a auth-xxxxxxx

9. Confira os pods criados durante a implantação. O Kubernetes cria o pod único quando o ReplicaSet é gerado:

kubectl get pods

Agora vamos criar um serviço para a implantação de "auth". Você já conferiu os arquivos de manifesto de serviço, então não vamos entrar em detalhes sobre isso aqui.

10. Use o comando kubectl create para criar o serviço auth:

kubectl create -f services/auth.yaml

11. Agora, faça o mesmo para criar e expor a implantação de "hello":

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

12. Repita o processo mais uma vez para criar e expor a implantação de "frontend":

kubectl create secret generic tls-certs --from-file tls/ 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: você criou um ConfigMap para "frontend".

13. Interaja com "frontend" capturando seu IP externo e usando o comando "curl":

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 -ks https://<EXTERNAL-IP>

Você vai receber a resposta "hello".

14. Você também pode usar o recurso de modelagem de saída do kubectl para usar "curl" como uma opção:

curl -ks https://`kubectl get svc frontend -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`

Testar a tarefa concluída

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório. Se o cluster e as implantações "auth", "hello" e "frontend" do Kubernetes tiverem sido criados corretamente, a pontuação de avaliação vai ser mostrada.

Crie um cluster e implantações ("auth", "hello" e "frontend") 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. Para saber uma explicação sobre esse campo, use o comando kubectl explain de novo:

kubectl explain deployment.spec.replicas

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

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

Depois que a implantação for atualizada, o Kubernetes vai ajustar automaticamente o ReplicaSet associado e iniciar novos pods até atingir um total de cinco.

3. Confirme que agora existem cinco pods hello em execução:

kubectl get pods | grep hello- | wc -l

4. Agora diminua o escalonamento do aplicativo:

kubectl scale deployment hello --replicas=3

5. Novamente, confirme que você tem o número correto de pods:

kubectl get pods | grep hello- | wc -l

Você aprendeu sobre implantações do Kubernetes e 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. Quando uma implantação é atualizada para uma nova versão, ela cria um novo ReplicaSet e aumenta lentamente o número de réplicas no novo ReplicaSet à medida que diminui as réplicas no antigo ReplicaSet.

Acionar uma atualização gradual

1. Para atualizar sua implantação, execute o seguinte comando:

kubectl edit deployment hello

2. Altere image na seção de contêineres da implantação para o seguinte:

... containers: image: kelseyhightower/hello:2.0.0 ...

3. Salve e saia.

Depois de salvar e sair do editor, a implantação atualizada será salva no seu cluster, e o Kubernetes vai iniciar uma atualização gradual.

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/hello

Pausar uma atualização gradual

Se você detectar problemas em um lançamento em execução, pause-o para interromper a atualização.

1. Faça isso agora:

kubectl rollout pause deployment/hello

2. Verifique o estado atual do lançamento:

kubectl rollout status deployment/hello

3. Você também pode conferir isso diretamente nos pods:

kubectl get pods -o jsonpath --template='{range .items[*]}{.metadata.name}{"\t"}{"\t"}{.spec.containers[0].image}{"\n"}{end}'

Retomar uma atualização gradual

O lançamento está pausado, o que significa que alguns pods estão na nova versão, e outros, na mais antiga.

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

kubectl rollout resume deployment/hello

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

kubectl rollout status deployment/hello

Saída:

deployment "hello" successfully rolled out

Reverter uma atualização

Suponha que um bug tenha sido detectado na sua nova versão. Como ela provavelmente apresentará problemas, todos os usuários conectados aos novos pods terão esses problemas.

Reverta para a versão anterior, investigue o problema e depois publique a versão corrigida.

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

kubectl rollout undo deployment/hello

2. Verifique a reversão no histórico:

kubectl rollout history deployment/hello

3. Por fim, confirme que todos os pods foram revertidos para as versões anteriores:

kubectl get pods -o jsonpath --template='{range .items[*]}{.metadata.name}{"\t"}{"\t"}{.spec.containers[0].image}{"\n"}{end}'

Ótimo. Você aprendeu sobre atualizações graduais para implantações do Kubernetes e como atualizar aplicativos sem tempo de inatividade.

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. As implantações canário permitem que você publique uma alteração para um pequeno subgrupo de usuários, reduzindo o risco associado a novas versões.

Criar uma implantação canário

Uma implantação canário é uma implantação separada que contém sua nova versão e um serviço destinado tanto à implantação normal e estável quanto à implantação canário.

1. Primeiro, crie uma implantação canário para a nova versão:

cat deployments/hello-canary.yaml

Saída:

apiVersion: apps/v1 kind: Deployment metadata: name: hello-canary spec: replicas: 1 selector: matchLabels: app: hello template: metadata: labels: app: hello track: canary # Use ver 2.0.0 so it matches version on service selector version: 2.0.0 spec: containers: - name: hello image: kelseyhightower/hello:2.0.0 ports: - name: http containerPort: 80 - name: health containerPort: 81 ...

2. Agora crie a implantação canário:

kubectl create -f deployments/hello-canary.yaml

3. Quando a implantação canário for criada, você terá duas implantações, hello e hello-canary. Use o comando kubectl para verificá-las.

kubectl get deployments

No serviço hello, o seletor usa app:hello, que vai fazer a correspondência dos pods nas duas implantações, a de produção e a canário. No entanto, como a implantação canário tem menos pods, ela ficará visível para menos usuários.

Verificar a implantação canário

1. É possível verificar a versão de hello que está sendo atendida pela solicitação:

curl -ks https://`kubectl get svc frontend -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

2. Execute esse comando várias vezes. Você vai perceber que algumas solicitações são atendidas por "hello 1.0.0", e um pequeno subconjunto (1/4 = 25%) é atribuído à versão 2.0.0.

Testar a tarefa concluída

Clique em Verificar meu progresso abaixo 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

Implantações canário em produção - afinidade da sessão

Neste laboratório, cada solicitação enviada ao serviço Nginx teve a chance de ser atendida pela implantação canário. E se você quisesse garantir que um usuário não fosse atendido pela implantação canário? Por exemplo, se a IU de um aplicativo tiver sido alterada e você não quiser confundir o usuário. Em uma situação como essa, é preferível que o usuário permaneça em apenas uma das implantações.

Você pode fazer isso criando um serviço com afinidade da sessão. Dessa forma, o mesmo usuário será sempre atendido pela mesma versão. No exemplo abaixo, o serviço é o mesmo de antes, mas um novo campo sessionAffinity foi adicionado e definido como ClientIP. As solicitações de todos os clientes com um determinado endereço IP serão enviadas para a mesma versão do aplicativo hello.

kind: Service apiVersion: v1 metadata: name: "hello" spec: sessionAffinity: ClientIP selector: app: "hello" ports: - protocol: "TCP" port: 80 targetPort: 80

Como é difícil configurar um ambiente para testar, você não precisa fazer isso aqui, mas pode ser conveniente usar sessionAffinity para implantações canário em produção.

Tarefa 5: Implantações azul-verde

As atualizações graduais são vantajosas porque permitem que você implante um aplicativo lentamente com o mínimo de sobrecarga, de impacto no desempenho e de tempo de inatividade. Em algumas situações, o ideal é apontar os balanceadores de carga para essa nova versão somente depois que ela tiver sido totalmente implantada. Nesse caso, as implantações azul-verde são o melhor caminho.

O Kubernetes faz isso criando duas implantações separadas; uma para a antiga versão "azul" e outra para a nova versão "verde". Use sua implantação de hello para a versão "azul". As implantações serão acessadas por um serviço que atuará como roteador. Quando a nova versão "verde" estiver em execução, você vai passar a usar essa versão ao atualizar o serviço.

Observação: a principal desvantagem das implantações azul-verde é que você vai precisar ter pelo menos o dobro dos recursos necessários em seu cluster para hospedar o aplicativo. Verifique se você tem recursos suficientes em seu cluster antes de implantar as duas versões do aplicativo de uma só vez.

O serviço

Use o serviço "hello", mas atualize para que ele tenha um seletor app:hello, version: 1.0.0.. O seletor corresponderá à implantação "azul". Ele não corresponderá à implantação "verde", porque usará uma versão diferente.

• Primeiro, atualize o serviço:

kubectl apply -f services/hello-blue.yaml Observação: ignore o aviso resource service/hello is missing porque ele é corrigido automaticamente.

Como atualizar usando a implantação azul-verde

Para oferecer suporte a um estilo de implantação azul-verde, você vai criar uma nova implantação "verde" para a nova versão. A implantação verde atualiza o rótulo da versão e o caminho da imagem.

apiVersion: apps/v1 kind: Deployment metadata: name: hello-green spec: replicas: 3 selector: matchLabels: app: hello template: metadata: labels: app: hello track: stable version: 2.0.0 spec: containers: - name: hello image: kelseyhightower/hello:2.0.0 ports: - name: http containerPort: 80 - name: health containerPort: 81 resources: limits: cpu: 0.2 memory: 10Mi livenessProbe: httpGet: path: /healthz port: 81 scheme: HTTP initialDelaySeconds: 5 periodSeconds: 15 timeoutSeconds: 5 readinessProbe: httpGet: path: /readiness port: 81 scheme: HTTP initialDelaySeconds: 5 timeoutSeconds: 1

1. Crie a implantação verde:

kubectl create -f deployments/hello-green.yaml

2. Depois que você tiver uma implantação verde e ela tiver sido iniciada corretamente, confirme que a versão atual da 1.0.0 ainda está sendo usada:

curl -ks https://`kubectl get svc frontend -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

3. Agora, aponte para a nova versão para atualizar o serviço:

kubectl apply -f services/hello-green.yaml

4. Depois de atualizar o serviço, a implantação "verde" será usada imediatamente. Agora, é possível verificar que a nova versão está sempre sendo usada.

curl -ks https://`kubectl get svc frontend -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

Reversão azul-verde

Se necessário, é possível reverter para a versão antiga da mesma maneira.

1. Enquanto a implantação "azul" ainda estiver em execução, basta atualizar o serviço de volta para a versão antiga.

kubectl apply -f services/hello-blue.yaml

2. A reversão vai ocorrer após a atualização do serviço. De novo, verifique se a versão correta está sendo usada agora:

curl -ks https://`kubectl get svc frontend -o=jsonpath="{.status.loadBalancer.ingress[0].ip}"`/version

Você conseguiu! Você aprendeu sobre implantações azul-verde e a implantar atualizações em aplicativos que precisam alternar as versões de uma só vez.

Parabéns!

Isso conclui este laboratório prático de gerenciamento de implantações com o Kubernetes. 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. Agora que você concluiu o laboratório, pode aplicar essas habilidades ao seu próprio trabalho de DevOps.

Próximas etapas/Saiba mais

• No site do Google Cloud, é possível saber mais sobre:

  • Padrões de implantação com Kubernetes.
  • Guias e soluções de DevOps na documentação do Google Cloud.

• Acesse o site do Kubernetes para fazer parte da comunidade!

Treinamento e certificação do Google Cloud

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

Manual atualizado em 26 de janeiro de 2024

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