Canais de entrega contínua com Spinnaker e Kubernetes Engine

Neste tutorial, mostramos como criar um canal de entrega contínua usando o Google Kubernetes Engine, Cloud Source Repositories, Cloud Build e 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

arquitetura de canal

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.

Canal de entrega de aplicativos

Objetivos

  • Definir o ambiente iniciando o Cloud Shell, criando um cluster do GKE e configurando o esquema de gerenciamento de identidade e usuário.
  • 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, acionando 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 se qualificar 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 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 exemplo 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 a função storage.admin à sua 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. Você precisará dessa chave mais tarde quando instalar o Spinnaker e fizer o 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 o tópico já foi criado para você.

    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 partir da 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ê usa 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 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 porta 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.

    port8080

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

    hello

    spinui

Como criar 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 dos commits do Git nesse repositório. Substitua [EMAIL_ADDRESS] pelo seu endereço de e-mail do Git e substitua [USERNAME] por seu nome de usuário do Git.

    git config --global user.email "[EMAIL_ADDRESS]"
    git config --global user.name "[USERNAME]"
    

  5. Faça o commit 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

Configurar os acionadores de versão

Nesta seção, você configura o Container Builder 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.

Fluxo de trabalho do Spinnaker

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

    IR PARA A PÁGINA "CRIAR ACIONADORES"

  2. Selecione o Cloud Source Repository e clique em Continuar.

  3. Selecione o repositório sample-app recém-criado na lista e clique em Continuar.
  4. Defina as seguintes configurações do acionador:

    • Nome:sample-app-tags
    • Trigger type: Tag
    • Tag (regex): v.*
    • Configuração de criação: cloudbuild.yaml
    • Local de cloudbuild.yaml: /cloudbuild.yaml

  5. Clique em Criar acionador.

    Criar um acionador

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 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. No Container Build, 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.

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.

configurar o canal de implantação

Instalar o spin CLI para gerenciar o Spinnaker

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

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

    curl -LO https://storage.googleapis.com/spinnaker-artifacts/spin/$(curl -s https://storage.googleapis.com/spinnaker-artifacts/spin/latest)/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 suas etapas. As etapas em azul estão em execução, as verdes foram concluídas com sucesso e as vermelhas falharam. Clique no cenário 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. Passe o cursor sobre o ícone amarelo "pessoa" e clique em Continuar.

    enviar para produção

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

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

    balanceadores de carga

  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 o painel de detalhes à direita e copie o endereço IP do seu aplicativo clicando no botão da área de transferência no IP de entrada.

    Copie o endereço IP do seu aplicativo

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

    back-end

    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 canárias. Quando a implantação é pausada aguardando a implementação para produção, comece a atualizar a guia que contém o aplicativo. Nove 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 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 é concluído, o aplicativo se parece com a seguinte captura de tela. Observe que a cor mudou para azul graças à alteração de código e que o campo Versão agora exibe v1.0.1.

    back-end do aplicativo

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

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

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

Como fazer a 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 exemplo:

    kubectl delete -f k8s/services
    

  3. Exclua a conta de serviço:

    export SA_EMAIL=$(gcloud iam service-accounts list \
        --filter="displayName:spinnaker-storage-account" --format='value(email)')
    gcloud iam service-accounts delete $SA_EMAIL
    

  4. Exclua o cluster do GKE:

    gcloud container clusters delete spinnaker-tutorial
    

  5. Exclua o repositório:

    gcloud source repos delete sample-app
    

  6. Excluir o intervalo:

    export PROJECT=$(gcloud info --format='value(config.project)')
    export BUCKET=$PROJECT-spinnaker-config
    gsutil -m rm -r gs://$BUCKET
    

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

  8. Se você criou v1.0.2 na etapa de rollback opcional acima, exclua essa imagem do contêiner:

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

Próximas etapas

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

Enviar comentários sobre…