Implantação contínua no Google Kubernetes Engine (GKE) com o Cloud Build

1. Visão geral

Neste laboratório, você vai aprender a configurar um pipeline de entrega contínua para GKE com o Cloud Build. Este laboratório destaca como acionar jobs do Cloud Build para diferentes eventos do git, além de mostrar um padrão simples para versões canário automatizadas no GKE.

Você concluirá as seguintes etapas:

• Crie o aplicativo do GKE
• Automatizar implantações para ramificações Git
• Automatizar implantações para a ramificação git main
• Automatizar implantações para tags git

2. Antes de começar

Para este guia de referência, você precisa de um projeto do Google Cloud. É possível criar um novo projeto ou selecionar um que você já tenha criado:

1. Selecione ou crie um projeto do Google Cloud.

ACESSAR A PÁGINA DO SELETOR DE PROJETOS

1. Ative o faturamento no projeto.

ATIVAR FATURAMENTO

3. como preparar o ambiente

1. Crie variáveis de ambiente para usar neste tutorial:

   export PROJECT_ID=$(gcloud config get-value project)
   export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')
   
   export ZONE=us-central1-b
   export CLUSTER=gke-progression-cluster
   export APP_NAME=myapp
   

2. Ative as seguintes APIs:
   • Resource Manager
   • GKE
   • Cloud Source Repositories
   • Cloud Build
   • Container Registry

   gcloud services enable \
       cloudresourcemanager.googleapis.com \
       container.googleapis.com \
       sourcerepo.googleapis.com \
       cloudbuild.googleapis.com \
       containerregistry.googleapis.com \
       --async
   

3. Clone a origem da amostra e alterne para o diretório do laboratório:

   git clone https://github.com/GoogleCloudPlatform/software-delivery-workshop.git gke-progression
   
   cd gke-progression/labs/gke-progression
   rm -rf ../../.git
   

4. Substitua os valores do marcador no repositório de amostra pelo PROJECT_ID:nesta etapa, você vai criar instâncias dos vários arquivos de configuração exclusivos do ambiente atual.Para conferir um exemplo dos modelos que estão sendo atualizados, execute o comando a seguir.

   cat k8s/deployments/dev/frontend-dev.yaml.tmpl
   

   Execute a substituição de variável executando o comando "segue".

   for template in $(find . -name '*.tmpl'); do envsubst '${PROJECT_ID} ${ZONE} ${CLUSTER} ${APP_NAME}' < ${template} > ${template%.*}; done
   

   Para analisar um exemplo do arquivo após a substituição, execute o comando a seguir.

   cat k8s/deployments/dev/frontend-dev.yaml
   

5. Se você nunca usou o Git no Cloud Shell, defina os valores user.name e user.email que quer usar:

   git config --global user.email "YOUR_EMAIL_ADDRESS"
   git config --global user.name "YOUR_USERNAME"
   

6. Armazene o código do repositório de amostra no Cloud Source Repositories:

   gcloud source repos create gke-progression
   git init
   git config credential.helper gcloud.sh
   git remote add gcp https://source.developers.google.com/p/$PROJECT_ID/r/gke-progression
   git branch -m main
   git add . && git commit -m "initial commit"
   git push gcp main
   

7. Crie seu cluster do GKE.

   gcloud container clusters create ${CLUSTER} \
       --project=${PROJECT_ID} \
       --zone=${ZONE}
   

8. Conceda os direitos do Cloud Build ao cluster.O Cloud Build vai implantar o aplicativo no cluster do GKE e precisará de direitos para fazer isso.

   gcloud projects add-iam-policy-binding ${PROJECT_ID} \
       --member=serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com \
       --role=roles/container.developer
   

Seu ambiente está pronto.

4. Como criar um aplicativo do GKE

Nesta seção, você criará e implantará o aplicativo de produção inicial usado ao longo deste tutorial.

1. Crie o aplicativo com o Cloud Build:

   gcloud builds submit --tag gcr.io/$PROJECT_ID/$APP_NAME:1.0.0 src/
   

2. Implantar manualmente em ambientes canário e de produção:crie as implantações e os serviços de produção e canário usando os comandos kubectl apply.

   kubectl create ns production
   kubectl apply -f k8s/deployments/prod -n production
   kubectl apply -f k8s/deployments/canary -n production
   kubectl apply -f k8s/services -n production
   

   O serviço implantado aqui roteará o tráfego para as implantações canário e de produção.
3. Analise o número de pods em execução Confirme se você tem quatro pods em execução para o front-end, incluindo três para o tráfego de produção e um para as versões canário. Isso significa que as mudanças na versão canário vão afetar apenas 1 em cada 4 (25%) dos usuários.

   kubectl get pods -n production -l app=$APP_NAME -l role=frontend
   

4. Recupere o endereço IP externo dos serviços de produção.

   Observação:o endereço IP externo do balanceador de carga talvez leve alguns minutos para aparecer.

   .

   kubectl get service $APP_NAME -n production
   

   Depois que o balanceador de carga retornar o endereço IP, continue para a próxima etapa.
5. Armazenar o IP externo para uso posterior.

   export PRODUCTION_IP=$(kubectl get -o jsonpath="{.status.loadBalancer.ingress[0].ip}"  --namespace=production services $APP_NAME)
   

6. Analise o aplicativo. Verifique a saída da versão do serviço. Deve estar escrito "Hello World v1.0"

   curl http://$PRODUCTION_IP
   

Parabéns! Você implantou o app de amostra. Em seguida, configure acionadores para implantar continuamente as alterações.

5. Como automatizar implantações para ramificações do Git

Nesta seção, você vai configurar um gatilho que executará um job do Cloudbuild na confirmação de qualquer ramificação diferente de main. O arquivo do Cloud Build usado aqui cria automaticamente um namespace e uma implantação para qualquer ramificação atual ou nova, permitindo que os desenvolvedores visualizem o código antes da integração com a ramificação principal.

1. Configure o gatilho:o principal componente desse gatilho é o uso do parâmetro branchName para corresponder a main e o parâmetro invertRegex, que é definido como verdadeiro e altera o padrão branchName para corresponder a tudo que não seja main. Para sua referência, você encontra as seguintes linhas em build/branch-trigger.json.

     "branchName": "main",
     "invertRegex": true
   

   Além disso, as últimas linhas do arquivo do Cloud Build usado com esse gatilho criam um namespace com o nome da ramificação que acionou o job e implanta o aplicativo e o serviço no novo namespace. Para sua referência, você encontra as seguintes linhas em build/branch-cloudbuild.yaml

     kubectl get ns ${BRANCH_NAME} || kubectl create ns ${BRANCH_NAME}
     kubectl apply --namespace ${BRANCH_NAME} --recursive -f k8s/deployments/dev
     kubectl apply --namespace ${BRANCH_NAME} --recursive -f k8s/services
   

   Agora que você conhece os mecanismos em uso, crie o gatilho com o comando gcloud abaixo.

   gcloud beta builds triggers create cloud-source-repositories \
     --trigger-config build/branch-trigger.json
   

2. Para revisar o gatilho, acesse a página Gatilhos do Cloud Build no console.Acessar Gatilhos
3. Criar uma nova ramificação:

   git checkout -b new-feature-1
   

4. Modifique o código para indicar a v1.1. Editar src/app.py e mudar a resposta de 1.0 para 1.1

   @app.route('/')
   def hello_world():
       return 'Hello World v1.1'
   

5. Confirme a alteração e envie-a por push ao repositório remoto:

   git add . && git commit -m "updated" && git push gcp new-feature-1
   

6. Para revisar o build em andamento, acesse a página Cloud Build History no console.Acesse BuildsQuando o build estiver concluído, siga para a próxima etapa
7. Recupere o endereço IP externo do serviço da ramificação recém-implantado.

   Observação:o endereço IP externo do balanceador de carga talvez leve alguns minutos para aparecer.

   .

   kubectl get service $APP_NAME -n new-feature-1
   

   Depois que o balanceador de carga retornar o endereço IP, continue para a próxima etapa.
8. Armazenar o IP externo para uso posterior.

   export BRANCH_IP=$(kubectl get -o jsonpath="{.status.loadBalancer.ingress[0].ip}"  --namespace=new-feature-1 services $APP_NAME)
   

9. Analise a saída da versão do serviço do application. Deve estar escrito "Hello World v1.0"

   curl http://$BRANCH_IP
   

6. Como automatizar implantações para a ramificação git main

Antes do lançamento do código para produção, é comum liberá-lo para um pequeno subconjunto de tráfego ativo antes de migrar todo o tráfego para a nova base de código.

Nesta seção, você implementará um acionador que será ativado quando o código for confirmado na ramificação principal. O gatilho implanta a implantação canário, que recebe 25% de todo o tráfego ativo para a nova revisão.

1. Configure o gatilho para a ramificação principal:

   gcloud beta builds triggers create cloud-source-repositories \
     --trigger-config build/main-trigger.json
   

2. Para analisar o novo gatilho, acesse a página Gatilhos do Cloud Build no console.Acessar Gatilhos
3. Mescle a ramificação à linha principal e envie por push ao repositório remoto:

   git checkout main
   git merge new-feature-1
   git push gcp main
   

4. Para revisar o build em andamento, acesse a página Cloud Build History no console.Acesse BuildsQuando o build estiver concluído, siga para a próxima etapa
5. Analise várias respostas do serverExecute o comando a seguir e observe que aproximadamente 25% das respostas mostram a nova resposta Hello World v1.1

   while true; do curl -w "\n" http://$PRODUCTION_IP; sleep 1;  done
   

   Quando estiver tudo pronto para continuar, pressione Ctrl+c para sair da repetição.

7. Automatizar implantações para tags git

Depois que a implantação canário é validada com um pequeno subconjunto de tráfego, você libera a implantação para o restante do tráfego ativo.

Nesta seção, você configurará um gatilho que é ativado quando você cria uma tag no repositório. O acionador identifica a imagem com a tag apropriada e implanta as atualizações para produção, garantindo que 100% do tráfego esteja acessando a imagem marcada.

1. Configure o acionador de tags:

   gcloud beta builds triggers create cloud-source-repositories \
     --trigger-config build/tag-trigger.json
   

2. Para analisar o novo gatilho, acesse a página Gatilhos do Cloud Build no console.Acessar Gatilhos
3. Crie uma nova tag e envie-a ao repositório remoto:

   git tag 1.1
   git push gcp 1.1
   

4. Para analisar o build em andamento, acesse a página Histórico do Cloud Build no console.Acessar Builds
5. Analise várias respostas do serverExecute o comando a seguir e observe que 100% das respostas mostram a nova resposta do Hello World v1.1. Isso pode demorar um pouco enquanto os novos pods são implantados e a integridade verificada no GKE

   while true; do curl -w "\n" http://$PRODUCTION_IP; sleep 1;  done
   

   Quando estiver pronto para continuar, pressione Ctrl+c para sair do loop.Parabéns! Você criou gatilhos de CI/CD no Cloud Build para ramificações e tags e implantar apps no GKE.

8. Limpeza

Excluir o projeto

Cuidado: excluir um projeto causa os seguintes efeitos: tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.

1. No console do Cloud, acesse a página Gerenciar recursos.
2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.