Canais de entrega contínua com Spinnaker e Kubernetes Engine

Neste tutorial, mostramos como criar um pipeline de entrega contínua usando o Google Kubernetes Engine (GKE), o Cloud Source Repositories, o Cloud Build e o Spinnaker. Depois de criar um aplicativo de exemplo, configure esses serviços para criar, testar e implantar automaticamente. Quando você modifica o código do aplicativo, as alterações acionam o canal de entrega contínua para recriar, retestar e reimplantar a nova versão automaticamente.

Arquitetura de canal

O diagrama a seguir ilustra a arquitetura do pipeline de entrega contínua.

Arquitetura de pipeline para desenvolvedores e usuários.

Para realizar a entrega contínua das atualizações de aplicativos aos usuários, é necessário ter um processo automatizado para criar, testar e atualizar seu software de maneira confiável. As alterações de código precisam fluir automaticamente por meio de um canal que inclua criação de artefatos, teste de unidade, teste funcional e implementação na produção. Em alguns casos, é interessante que uma atualização de código se aplique apenas a um subconjunto dos usuários, para que seja exercida de maneira realista antes do envio para toda a base de usuários. Se uma dessas versões canário for insatisfatória, o procedimento automatizado precisará reverter rapidamente as alterações no software.

Com o GKE e o Spinnaker, é possível criar um fluxo eficiente de entrega contínua para ajudar a garantir que o envio do software seja tão rápido quanto o desenvolvimento e a validação. Ainda que a iteração rápida seja o objetivo final, é preciso garantir que cada revisão do aplicativo passe por diversas validações automatizadas antes de se tornar um candidato para implementação na produção. Quando uma determinada alteração é controlada por meio de automação, é possível validar o aplicativo manualmente e realizar outros testes de pré-lançamento também.

Depois que sua equipe decidir que o aplicativo está pronto para a produção, um dos membros da equipe pode aprová-lo para a implantação da produção.

Canal de entrega de aplicativos

Neste tutorial, você criará o canal de entrega contínua mostrado no diagrama a seguir.

Arquitetura do pipeline de entrega de aplicativos.

As etapas gerais do pipeline são as seguintes:

  1. Um desenvolvedor altera o código e o envia para um repositório.

  2. O Cloud Build detecta as alterações, cria a imagem do Docker, testa a imagem e a envia para o Spinnaker.

  3. O Spinnaker detecta a imagem, implanta a imagem em uma implantação canário e testa a implantação. Após uma aprovação manual, o Spinnaker implanta a imagem na produção.

Objetivos

  • Definir o ambiente iniciando o Cloud Shell, criando um cluster do GKE e configurando o esquema de gerenciamento de identidade e usuários.
  • Fazer o download de um aplicativo de amostra, criar um repositório Git e fazer upload dele para um Cloud Source Repository.
  • Implantar o Spinnaker no GKE usando o Helm.
  • Criar a imagem do Docker.
  • Criar acionadores para gerar imagens do Docker quando o aplicativo for alterado.
  • Configurar um canal do Spinnaker para implantar de maneira confiável e contínua seu aplicativo no GKE.
  • Implantar uma mudança de código para acionar o canal e assistir a implantação para produção.

Custos

Neste tutorial, há componentes do Google Cloud Platform (GCP) que podem ser cobrados, inclusive estes:

  • GKE
  • Cloud Load Balancing
  • Cloud Build

Use a calculadora de preços para gerar uma estimativa de custo baseada na projeção de uso.

Novos usuários do GCP podem estar qualificados para uma avaliação gratuita.

Antes de começar

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do GCP.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    Saiba como ativar o faturamento

  4. Ativar GKE, Cloud Build e Cloud Source Repositories APIs.

    Ativar as APIs

Configure o ambiente

Nesta seção, você configurará a infraestrutura e as identidades necessárias para concluir o tutorial.

Iniciar uma instância do Cloud Shell e criar um cluster do GKE

Todos os comandos do terminal neste tutorial são executados a partir do Cloud Shell.

  1. Abra o Cloud Shell:

    ABRIR o Cloud Shell

  2. Crie um cluster do GKE para implantar o Spinnaker e o aplicativo de amostra com os seguintes comandos:

    gcloud config set compute/zone us-central1-f
    
    gcloud container clusters create spinnaker-tutorial \
        --machine-type=n1-standard-2
    

Configurar o gerenciamento de identidade e acesso

Você cria uma conta de serviço do Cloud Identity and Access Management (Cloud IAM) para delegar permissões ao Spinnaker, permitindo que ele armazene dados no Cloud Storage. O Spinnaker armazena os dados de canal no Cloud Storage para garantir confiabilidade e resiliência. No caso de uma falha inesperada na implantação do Spinnaker, crie uma implantação idêntica em minutos com acesso aos mesmos dados do canal original.

  1. Crie a conta de serviço:

    gcloud iam service-accounts create  spinnaker-account \
        --display-name spinnaker-account
    
  2. Armazene o endereço de e-mail da conta de serviço e o código do projeto atual nas variáveis de ambiente para uso em comandos posteriores:

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-account" \
        --format='value(email)')
    export PROJECT=$(gcloud info --format='value(config.project)')
    
  3. Vincule o papel storage.admin à conta de serviço:

    gcloud projects add-iam-policy-binding \
        $PROJECT --role roles/storage.admin --member serviceAccount:$SA_EMAIL
    
  4. Faça o download da chave da conta de serviço. Essa chave será necessária mais tarde quando você instalar o Spinnaker e fizer upload da chave no GKE.

    gcloud iam service-accounts keys create spinnaker-sa.json --iam-account $SA_EMAIL
    

Configurar o Cloud Pub/Sub para acionar canais do Spinnaker

  1. Crie o tópico Cloud Pub/Sub para notificações do Container Registry. Esse comando pode falhar e apresentar o erro "O recurso já existe no projeto", o que significa que você já criou o tópico.

    gcloud beta pubsub topics create projects/$PROJECT/topics/gcr
    
  2. Crie uma assinatura que o Spinnaker possa ler para receber notificações de envio de imagens.

    gcloud beta pubsub subscriptions create gcr-triggers \
        --topic projects/${PROJECT}/topics/gcr
    
  3. Conceda as permissões da conta de serviço do Spinnaker para ler a assinatura gcr-triggers.

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-account" \
        --format='value(email)')
    gcloud beta pubsub subscriptions add-iam-policy-binding gcr-triggers \
        --role roles/pubsub.subscriber --member serviceAccount:$SA_EMAIL
    

Como implantar o Spinnaker usando o Helm

Nesta seção, você usará o Helm para implantar o Spinnaker do repositório de gráficos. O Helm é um gerenciador de pacotes que pode ser usado para configurar e implantar aplicativos do Kubernetes.

Instalar o Helm

  1. Faça o download e instale o binário do helm:

    wget https://storage.googleapis.com/kubernetes-helm/helm-v2.10.0-linux-amd64.tar.gz
    
  2. Descompacte o arquivo no sistema local:

    tar zxfv helm-v2.10.0-linux-amd64.tar.gz
    
    cp linux-amd64/helm .
    
  3. Conceda ao Tiller, o servidor do Helm, o papel de administrador do seu cluster:

    kubectl create clusterrolebinding user-admin-binding --clusterrole=cluster-admin --user=$(gcloud config get-value account)
    kubectl create serviceaccount tiller --namespace kube-system
    kubectl create clusterrolebinding tiller-admin-binding --clusterrole=cluster-admin --serviceaccount=kube-system:tiller
    
  4. Conceda ao Spinnaker o papel cluster-admin para que ele possa implantar recursos em todos os namespaces:

    kubectl create clusterrolebinding --clusterrole=cluster-admin --serviceaccount=default:default spinnaker-admin
    
  5. Inicialize o Helm para instalar o Tiller no seu cluster:

    ./helm init --service-account=tiller
    ./helm update
  6. Verifique se o Helm está instalado corretamente executando o seguinte comando. Se o Helm estiver instalado corretamente, v2.10.0 aparecerá tanto para o cliente quanto para o servidor.

    ./helm version
    Client: &version.Version{SemVer:"v2.10.0", GitCommit:"9ad53aac42165a5fadc6c87be0dea6b115f93090", GitTreeState:"clean"}
    Server: &version.Version{SemVer:"v2.10.0", GitCommit:"9ad53aac42165a5fadc6c87be0dea6b115f93090", GitTreeState:"clean"}
    

Configure o Spinnaker

  1. Crie um intervalo do Spinnaker para armazenar a configuração de canal:

    export PROJECT=$(gcloud info \
        --format='value(config.project)')
    export BUCKET=$PROJECT-spinnaker-config
    gsutil mb -c regional -l us-central1 gs://$BUCKET
  2. Crie o arquivo (spinnaker-config.yaml) descrevendo a configuração referente a como o Spinnaker deve ser instalado:

    export SA_JSON=$(cat spinnaker-sa.json)
    export PROJECT=$(gcloud info --format='value(config.project)')
    export BUCKET=$PROJECT-spinnaker-config
    cat > spinnaker-config.yaml <<EOF
    gcs:
      enabled: true
      bucket: $BUCKET
      project: $PROJECT
      jsonKey: '$SA_JSON'
    
    dockerRegistries:
    - name: gcr
      address: https://gcr.io
      username: _json_key
      password: '$SA_JSON'
      email: 1234@5678.com
    
    # Disable minio as the default storage backend
    minio:
      enabled: false
    
    # Configure Spinnaker to enable GCP services
    halyard:
      spinnakerVersion: 1.10.2
      image:
        tag: 1.12.0
      additionalScripts:
        create: true
        data:
          enable_gcs_artifacts.sh: |-
            \$HAL_COMMAND config artifact gcs account add gcs-$PROJECT --json-path /opt/gcs/key.json
            \$HAL_COMMAND config artifact gcs enable
          enable_pubsub_triggers.sh: |-
            \$HAL_COMMAND config pubsub google enable
            \$HAL_COMMAND config pubsub google subscription add gcr-triggers \
              --subscription-name gcr-triggers \
              --json-path /opt/gcs/key.json \
              --project $PROJECT \
              --message-format GCR
    EOF
    

Implantar o gráfico do Spinnaker

  1. Use a interface de linha de comando do Helm para implantar o gráfico com o conjunto de configurações. Em geral, esse comando leva de cinco a dez minutos para ser concluído.

    ./helm install -n cd stable/spinnaker -f spinnaker-config.yaml --timeout 600 \
        --version 1.1.6 --wait
  2. Depois que o comando for concluído, execute o seguinte comando para configurar o encaminhamento da portas para a IU do Spinnaker do Cloud Shell:

    export DECK_POD=$(kubectl get pods --namespace default -l "cluster=spin-deck" \
        -o jsonpath="{.items[0].metadata.name}")
    kubectl port-forward --namespace default $DECK_POD 8080:9000 >> /dev/null &
    
  3. Para abrir a interface do usuário do Spinnaker, clique em Visualização da Web no Cloud Shell e em Visualizar na porta 8080.

    Lista suspensa de visualização da Web com a visualização selecionada.

  4. Você verá a tela de boas-vindas, seguida da IU do Spinnaker:

    Tela de boas-vindas mostrando "Olá".

    Página inicial do Spinnaker.

Crie a imagem do Docker

Nesta seção, você configurará o Container Builder para detectar alterações no código-fonte do aplicativo, criar uma imagem do Docker e enviá-la para o Container Registry.

Criar o repositório de código-fonte

  1. No Cloud Shell, faça o download do código-fonte de amostra:

    wget https://gke-spinnaker.storage.googleapis.com/sample-app-v2.tgz
    
  2. Descompacte o código-fonte:

    tar xzfv sample-app-v2.tgz
    
  3. Altere os diretórios para o código-fonte:

    cd sample-app
    
  4. Defina o nome de usuário e o endereço de e-mail das confirmações do Git nesse repositório. Substitua [EMAIL_ADDRESS] pelo seu endereço de e-mail do Git e substitua [USERNAME] pelo seu nome de usuário do Git.

    git config --global user.email "[EMAIL_ADDRESS]"
    git config --global user.name "[USERNAME]"
    
  5. Faça a confirmação inicial no repositório de código-fonte:

    git init
    git add .
    git commit -m "Initial commit"
    
  6. Crie um repositório para hospedar o código:

    gcloud source repos create sample-app
    git config credential.helper gcloud.sh
    
  7. Adicione seu repositório recém-criado como remoto:

    export PROJECT=$(gcloud info --format='value(config.project)')
    git remote add origin https://source.developers.google.com/p/$PROJECT/r/sample-app
    
  8. Pressione o código para o branch mestre do novo repositório:

    git push origin master
  9. Verifique se o código-fonte é exibido no console:

    ACESSAR A PÁGINA DO CÓDIGO-FONTE

Configure os acionadores de versão

O diagrama a seguir mostra o acionador que você cria nesta seção.

Fluxo de trabalho do Spinnaker

Você configura o Cloud Build para criar e enviar suas imagens do Docker sempre que enviar tags do Git para o repositório de origem. O Container Builder verifica automaticamente o código-fonte, cria a imagem do Docker no Dockerfile do repositório e envia por push essa imagem para o Container Registry.

  1. No Console do GCP, na seção Cloud Build, clique em Criar acionadores.

    ACESSAR A PÁGINA "CRIAR ACIONADORES"

  2. Selecione Cloud Source Repository e clique em Continuar.

  3. Na lista, selecione o repositório sample-app recém-criado e clique em Continuar.

  4. Defina as seguintes configurações do acionador:

    • Nome: sample-app-tags
    • Tipo de acionador: Tag
    • Tag (regex): v.*
    • Configuração da versão: cloudbuild.yaml
    • Local do cloudbuild.yaml: cloudbuild.yaml
  5. Clique em Criar acionador.

    Configurações do acionador quando ele é criado.

A partir de agora, sempre que você enviar por push uma tag do Git iniciada com a letra "v" para o repositório de código-fonte, o Container Builder criará e efetuará push do aplicativo como uma imagem do Docker automaticamente no Container Registry.

Preparar manifestos do Kubernetes para uso no Spinnaker

O Spinnaker precisa acessar seus manifestos do Kubernetes para implantá-los nos clusters. Nesta seção, criaremos um intervalo do Cloud Storage que será preenchido com seus manifestos durante o processo de integração contínua (CI, na sigla em inglês) no Cloud Build. Depois que seus manifestos estiverem no Cloud Storage, o Spinnaker poderá fazer o download e aplicá-los durante a execução do seu canal.

  1. Crie o intervalo.

    export PROJECT=$(gcloud info --format='value(config.project)')
    gsutil mb -l us-central1 gs://$PROJECT-kubernetes-manifests
    
  2. Ative o controle de versão no intervalo para que você tenha um histórico dos seus manifestos.

    gsutil versioning set on gs://$PROJECT-kubernetes-manifests
    
  3. Defina o código do projeto do GCP correto nos manifestos de implantação do Kubernetes:

    sed -i s/PROJECT/$PROJECT/g k8s/deployments/*
    
  4. Confirme as mudanças no repositório:

    git commit -a -m "Set project ID"
    

Criar a imagem

Envie por push a primeira imagem usando as seguintes etapas:

  1. Vá para a pasta de código-fonte no Cloud Shell.
  2. Crie uma tag do Git:

    git tag v1.0.0
  3. Envie a tag por push:

    git push --tags
  4. Em Versão do Cloud, clique em Histórico da versão para verificar se a versão foi acionada. Caso contrário, verifique se o acionador foi configurado corretamente na seção anterior.

    VÁ PARA HISTÓRICO DA VERSÃO

    histórico de versões

Como configurar canais de implantação

Agora que as imagens estão sendo criadas automaticamente, é necessário implantá-las no cluster do Kubernetes.

O diagrama a seguir mostra as etapas do pipeline de implantação.

Configurar o pipeline de implantação.

A implantação é feita em um ambiente reduzido para testes de integração. Após a aprovação dos testes de integração, aprove manualmente as alterações para implantar o código nos serviços de produção.

Instalar o spin CLI para gerenciar o Spinnaker

O spin é um utilitário de linha de comando para gerenciar aplicativos e pipelines do Spinnaker.

  1. Faça o download da última versão do spin.

    curl -LO https://storage.googleapis.com/spinnaker-artifacts/spin/1.5.2/linux/amd64/spin
    
  2. Torne o spin executável.

    chmod +x spin
    

Criar o canal de implantação

  1. Use o spin para criar um aplicativo no Spinnaker.

    ./spin application save --application-name sample \
                            --owner-email example@example.com \
                            --cloud-providers kubernetes \
                            --gate-endpoint http://localhost:8080/gate
    

Em seguida, crie o canal de entrega contínua. Neste tutorial, o canal está configurado para detectar quando uma imagem do Docker com uma tag prefixada com "v" chegou no Container Registry.

  1. Em uma nova guia do Cloud Shell, execute o comando a seguir no diretório do código-fonte para fazer upload de um exemplo de canal para a instância do Spinnaker:

    export PROJECT=$(gcloud info --format='value(config.project)')
    sed s/PROJECT/$PROJECT/g spinnaker/pipeline-deploy.json > pipeline.json
    ./spin pipeline save --gate-endpoint http://localhost:8080/gate -f pipeline.json
    

Visualizar a execução do canal

A configuração que você acabou de criar usa notificações de imagens recém-marcadas enviadas para acionar um canal do Spinnaker. Em uma etapa anterior, você enviou uma tag para o Cloud Source Repositories que acionou o Cloud Build para criar e enviar sua imagem para o Container Registry. Agora é possível verificar o canal que foi acionado.

  1. Retorne à página "Canais" clicando em Canais.

  2. Clique em Detalhes para saber mais informações sobre o progresso do canal. Nesta seção, mostraremos o status do canal de implantação e as etapas relacionadas. As etapas em azul estão em execução, as verdes foram concluídas com sucesso e as vermelhas falharam. Clique na etapa para ver mais detalhes.

    Após 3 a 5 minutos, a fase de teste de integração é concluída e o canal requer aprovação manual para continuar a implantação.

  3. Coloque o cursor sobre Enviar para produção e clique em Continuar.

    A implementação continua para as implantações de front-end e back-end na produção. Ela será concluída após alguns minutos.

  4. Para ver o aplicativo, clique em Infraestrutura > Balanceadores de carga na parte superior da IU do Spinnaker.

    Lista suspensa de infraestrutura com balanceadores de carga selecionados.

  5. Role para baixo na lista de balanceadores de carga e clique em Padrão, que fica em sample-frontend-production.

    Balanceador de carga padrão.

  6. Role para baixo no painel de detalhes à direita e copie o endereço IP do seu aplicativo clicando no botão da área de transferência no IP do Ingress. O link do IP de ingresso da interface do usuário do Spinnaker usa HTTPS por padrão, mas o aplicativo está configurado para usar HTTP.

    Painel de detalhes com o endereço IP do seu aplicativo.

  7. Cole o endereço no navegador para exibir a versão de produção do aplicativo.

    Versão de produção do aplicativo.

    O canal foi acionado manualmente para criar, testar e implantar o aplicativo.

Como acionar o canal de alterações de código

Nesta seção, você testará o canal completamente, fazendo uma alteração de código, enviando uma tag do Git e observando o canal gerar uma resposta. Ao enviar uma tag do Git que começa com "v", você aciona o Container Builder para criar uma nova imagem do Docker e enviá-la para o Container Registry. O Spinnaker detecta que a nova tag de imagem contém o prefixo "v" e aciona um canal para implantar a imagem em versões canário, executar testes e implantar a mesma imagem em todos os pods na implantação.

  1. Altere a cor do aplicativo de laranja para azul:

    sed -i 's/orange/blue/g' cmd/gke-info/common-service.go
    
  2. Marque a alteração e envie-a por push para o repositório de código-fonte:

    git commit -a -m "Change color to blue"
    git tag v1.0.1
    git push --tags
    
  3. Veja a nova versão aparecer no Histórico de versões do Container Builder.

  4. Clique em Canais para ver o canal começar a implantar a imagem.

  5. Observe as implantações de canário. Quando a implantação for pausada, aguardando a implementação para produção, comece a atualizar a guia que contém o aplicativo. Quatro dos seus back-ends estão executando a versão anterior do aplicativo, enquanto apenas um back-end está executando o canário. Você verá a nova versão azul do aplicativo aparecer aproximadamente a cada décima vez que atualizar.

  6. Após a conclusão do teste, volte para a guia Spinnaker e aprove a implantação.

  7. Quando o canal for concluído, o aplicativo será parecido com a seguinte captura de tela. O campo Versão agora mostra v1.0.1.

    Versão de produção do aplicativo atualizado.

    Agora você implementou com sucesso o aplicativo em todo o ambiente de produção.

  8. Se quiser, desfaça essa alteração revertendo a confirmação anterior. A reversão adiciona uma nova tag (v1.0.2) e a envia de volta pelo mesmo canal usado para implantar v1.0.1:

    git revert v1.0.1
    git tag v1.0.2
    git push --tags

Limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

  1. Exclua a instalação do Spinnaker:

    ../helm delete --purge cd
    
  2. Exclua os serviços do aplicativo de amostra:

    kubectl delete -f k8s/services
    
  3. Remova as vinculações do IAM da conta de serviço:

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-account" --format='value(email)')
    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud projects remove-iam-policy-binding $PROJECT --role roles/storage.admin --member serviceAccount:$SA_EMAIL
    
  4. Exclua a conta de serviço:

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-account" --format='value(email)')
    gcloud iam service-accounts delete $SA_EMAIL
    
  5. Exclua o cluster do GKE:

    gcloud container clusters delete spinnaker-tutorial --zone=us-central1-f
    
  6. Exclua o repositório:

    gcloud source repos delete sample-app
    
  7. Excluir o intervalo:

    export PROJECT=$(gcloud info --format='value(config.project)')
    export BUCKET=$PROJECT-spinnaker-config
    gsutil -m rm -r gs://$BUCKET
    
  8. Exclua as imagens do contêiner:

    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.0
    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.1
    
  9. Se você criou v1.0.2 na etapa de reversão opcional acima, exclua essa imagem do contêiner:

    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.2
    

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…