Criar um canal de CI/CD com o Azure Pipelines e o Kubernetes Engine

Neste tutorial, mostramos como usar o Azure Pipelines, o Google Kubernetes Engine (GKE) e o Container Registry para criar uma integração e implantação contínuas (CI/CD). O tutorial usa o app da Web ASP.NET MusicStore, que é baseado no ASP.NET Core.

O pipeline de CI/CD usa dois clusters do GKE separados, um para desenvolvimento e outro para produção, como mostra o diagrama a seguir.

Diagrama conceitual do pipeline de CI/CD mostrando como desenvolvedores e usuários finais interagem com o aplicativo

No início do pipeline, os desenvolvedores confirmam as alterações no código de exemplo. Essa ação aciona o canal para criar uma versão e implantá-la no cluster de desenvolvimento. Um gerenciador de versões pode, então, promover a versão para que ela seja implantada no cluster de produção.

Este tutorial se destina a desenvolvedores e engenheiros de DevOps. Para segui-lo, é necessário ter conhecimento básico sobre .NET Core, Azure Pipelines e GKE. Também é preciso ter acesso administrativo a uma conta do Azure DevOps.

Objetivos

  • Conecte o Container Registry ao Azure Pipelines para publicar imagens do Docker.
  • Preparar um aplicativo de amostra .NET Core para implantação no GKE.
  • Autenticar com segurança no GKE sem precisar usar a autenticação legada.
  • Usar o gerenciamento de versões do Azure Pipelines para organizar as implantações do GKE.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem ser qualificados para uma avaliação gratuita.

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Como fazer a limpeza.

Verifique a página de preços do Azure DevOps para ver as taxas aplicáveis ao uso do Azure DevOps.

Antes de começar

Geralmente, é aconselhável usar projetos separados para cargas de trabalho de desenvolvimento e produção, de modo que os papéis e permissões do gerenciamento de identidade e acesso (IAM) possam ser concedidos individualmente. Para simplificar, neste tutorial é usado um único projeto para os dois clusters do GKE, um para desenvolvimento e outro para produção.

  1. No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar a página do seletor de projetos

  2. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

  3. É necessário ter uma conta Azure DevOps e ter acesso de administrador a ela. Se você ainda não tiver uma conta do Azure DevOps, inscreva-se na página inicial do Azure DevOps.

Como criar um projeto do Azure DevOps

Use o Azure DevOps para gerenciar o código-fonte, executar builds e testes e orquestrar a implantação no GKE. Para começar, crie um projeto na sua conta do Azure DevOps.

  1. Acesse a página inicial do Azure DevOps (https://dev.azure.com/YOUR_AZURE_DEVOPS_ACCOUNT_NAME).
  2. Clique em New project.
  3. Insira um nome de projeto, como Music Store.
  4. Defina Visibility como Private e clique em Create.
  5. Depois de criar o projeto, clique em Repos no menu à esquerda.
  6. Clique em Import para bifurcar o repositório MusicStore do GitHub e defina os seguintes valores:
    • Tipo de origem: Git
    • URL do clone: https://github.com/aspnet/MusicStore.git
  7. Clique em Import.

    Quando o processo de importação for concluído, será exibido o código-fonte do aplicativo MusicStore.

Como compilar continuamente

Agora, use o Azure Pipelines para configurar a integração contínua. Para cada confirmação enviada para o repositório Git, o Azure Pipelines compila o código e empacota os artefatos de compilação em um contêiner do Docker. Em seguida, o contêiner é publicado no Container Registry.

Como configurar a ramificação padrão

Este tutorial foi criado e testado com a versão 2.1 do aplicativo MusicStore. Para garantir que você esteja usando a mesma versão, configure o Azure Pipelines para usar a ramificação release/2.1 como padrão:

  1. No menu do Azure DevOps, selecione Project settings.
  2. Selecione Repos > Repositories.
  3. Na lista de repositórios, selecione o repositório Git que você importou anteriormente. Ele deve ter o mesmo nome do projeto do Azure DevOps.
  4. Clique na seta ao lado de Branches e expanda a lista de ramificações.
  5. Selecione a ramificação release/2.1. O botão ... aparecerá ao lado do nome da ramificação.
  6. Clique em ... e selecione Set as default branch.

Criar o código

Depois de criar a ramificação, comece a automatizar o build. Como o MusicStore é um aplicativo ASP.NET Core, a criação do código inclui quatro etapas:

  • Download e instalação de dependências
  • Compilação do código
  • Execução de testes de unidade
  • Publicação de resultados do build

Mais tarde, você incluirá outras etapas para implantação no GKE. Como o GKE é um ambiente baseado em Linux, você configura todo o processo de compilação para ser executado em agentes de compilação baseados em Linux.

  1. Usando o Visual Studio ou um cliente de linha de comando git, clone seu novo repositório Git.
  2. Na raiz do repositório, crie um arquivo chamado azure-pipelines.yml.
  3. Copie o seguinte código no arquivo:

    resources:
    - repo: self
      fetchDepth: 1
    queue:
      name: Hosted Ubuntu 1604
    trigger:
    - release/2.1
    variables:
      TargetFramework: 'netcoreapp2.1'
      RestoreBuildProjects: 'samples/**/*.csproj'
      TestProjects: 'test/MusicStore.Test/*.csproj'
      BuildConfiguration: 'Release'
      DockerImageName: 'PROJECT_ID/musicstore'
    steps:
    - task: DotNetCoreCLI@2
      displayName: Restore
      inputs:
        command: restore
        projects: '$(RestoreBuildProjects)'
        feedsToUse: config
        nugetConfigPath: NuGet.config
    - task: DotNetCoreCLI@2
      displayName: Build
      inputs:
        projects: '$(RestoreBuildProjects)'
        arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
    - task: DotNetCoreCLI@2
      displayName: Test
      inputs:
        command: test
        projects: '$(TestProjects)'
        arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
    - task: DotNetCoreCLI@2
      displayName: Publish
      inputs:
        command: publish
        publishWebProjects: True
        arguments: '--configuration $(BuildConfiguration) --framework=$(TargetFramework)'
        zipAfterPublish: false
        modifyOutputPath: false
    

    Substitua PROJECT_ID pelo nome do projeto e salve o arquivo.

  4. Confirme as alterações e envie-as para o Azure Pipelines.

    Visual Studio

    1. Abra o Team Explorer e clique no ícone Home.
    2. Clique em Changes.
    3. Insira uma mensagem de confirmação como Add build definition.
    4. Clique em Confirmar tudo e enviar por push.

    Linha de comando

    1. Organize todos os arquivos modificados:

      git add -A
      
    2. Confirme as alterações no repositório local:

      git commit -m "Add build definition"
      
    3. Envie as alterações para o Azure DevOps:

      git push
      
  5. No Azure, selecione Pipelines.

    Uma definição de compilação é criada com base no arquivo YAML que você confirmou no repositório Git.

Publicar imagens do Docker

Para implantar o aplicativo MusicStore no GKE, empacote o aplicativo como uma imagem de contêiner do Docker e disponibilize-o no Container Registry. Você usa o Container Registry no seu projeto de produção para esta tarefa.

Configurar uma conta de serviço para publicar imagens

Antes de configurar o Azure Pipelines para criar e publicar uma imagem de contêiner, você precisa garantir que o Azure Pipelines possa se autenticar com o Container Registry. Para isso, crie uma conta de serviço do Google Cloud no seu projeto de produção:

  1. Alterne para seu projeto no Console do Cloud.
  2. No Console do Cloud, ative o Cloud Shell.

    Ativar o Cloud Shell

  3. Para economizar tempo ao digitar suas opções de ID do projeto e zona do Compute Engine, defina os valores de configuração padrão executando os comandos a seguir:

    gcloud config set project PROJECT_ID
    gcloud config set compute/zone ZONE

    Substitua PROJECT_ID pelo ID do projeto do GCP e ZONE pelo nome da zona que você vai usar para criar recursos. Se não tiver certeza sobre qual zona escolher, use us-central1-a.

    Exemplo:

    gcloud config set project azure-pipelines-test-project-12345
    gcloud config set compute/zone us-central1-a
  4. Ative a API Container Registry para o projeto:

    gcloud services enable containerregistry.googleapis.com
  5. Crie uma conta de serviço para o Azure Pipelines publicar as imagens do Docker:

    gcloud iam service-accounts create azure-pipelines-publisher \
        --display-name "Azure Pipelines Publisher"
  6. Atribua o papel de IAM do Storage Admin à conta de serviço:

    AZURE_PIPELINES_PUBLISHER=azure-pipelines-publisher@$GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com
    
    gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT \
        --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
        --role roles/storage.admin
    
  7. Gere uma chave de conta de serviço:

    gcloud iam service-accounts keys create azure-pipelines-publisher.json \
        --iam-account $AZURE_PIPELINES_PUBLISHER
    
    tr -d '\n' < azure-pipelines-publisher.json > azure-pipelines-publisher-oneline.json
  8. No menu do Cloud Shell, clique em Open Editor.

  9. Abra o arquivo chamado azure-pipelines-publisher-oneline.json. Você precisará do conteúdo desse arquivo em uma das etapas a seguir.

Conectar o Azure Pipelines ao Container Registry

Depois de criar a conta de serviço, conecte o Azure Pipelines ao Container Registry.

  1. No menu do Azure DevOps, selecione Project settings e, em seguida, selecione Pipelines > Service connections.
  2. Clique em New service connection.
  3. Na lista, selecione Docker Registry e clique em Next.
  4. Na caixa de diálogo, insira valores para os campos a seguir:
    • Tipo de registro: Outros
    • Docker Registry: https://gcr.io/PROJECT_ID, substituindo PROJECT_ID pelo nome do projeto (por exemplo, https://gcr.io/azure-pipelines-test-project-12345).
    • ID do Docker: _json_key
    • Senha: cole o conteúdo de azure-pipelines-publisher-oneline.json.
    • Nome da conexão de serviço: gcr-tutorial
  5. Clique em Salvar para criar a conexão.

Criar um DockerFile

Agora é possível criar o Dockerfile que o Azure Pipelines usa para criar a imagem do contêiner.

  1. Na raiz do repositório, crie um arquivo chamado Dockerfile.
  2. Copie o código a seguir no arquivo e salve-o:

    FROM mcr.microsoft.com/dotnet/core/aspnet:2.1
    WORKDIR /app
    COPY samples/MusicStore/bin/Release/netcoreapp2.1/publish /app/
    COPY samples/MusicStore/config.json /app/
    
    ENV ASPNETCORE_URLS=http://0.0.0.0:8080
    
    ENTRYPOINT ["dotnet", "MusicStore.dll"]
    
  3. Crie um outro arquivo chamado deployment.yaml na raiz do espaço de trabalho do Git. Deixe o arquivo vazio por enquanto.

  4. Confirme as mudanças:

    Visual Studio

    1. Abra o Team Explorer e clique no ícone Home na parte superior esquerda para trocar para a visualização Home.
    2. Clique em Changes.
    3. Insira uma mensagem de confirmação como Add Dockerfile and placeholder for the Kubernetes manifest.
    4. Clique em Confirmar tudo.

    Linha de comando

    1. Organize todos os arquivos modificados:

      git add -A
      
    2. Confirme as alterações no repositório local:

      git commit -m "Add Dockerfile and placeholder for the Kubernetes manifest"
      

Estender a definição de compilação para criar uma imagem do Docker

Com todos os arquivos necessários recebidos, você pode estender a definição da compilação.

  1. Abra o arquivo azure-pipelines.yml.
  2. Para estender a definição da compilação, anexe o trecho de código a seguir ao arquivo.

    - task: CmdLine@1
      displayName: 'Lock image version in deployment.yaml'
      inputs:
        filename: /bin/bash
        arguments: '-c "awk ''{gsub(\"MUSICSTORE_IMAGE\", \"gcr.io/$(DockerImageName):$(Build.BuildId)\", $0); print}'' deployment.yaml > $(build.artifactstagingdirectory)/deployment.yaml"'
    - task: PublishBuildArtifacts@1
      displayName: 'Publish Artifact'
      inputs:
        PathtoPublish: '$(build.artifactstagingdirectory)'
    - task: Docker@0
      displayName: 'Build image'
      inputs:
        containerregistrytype: 'Container Registry'
        dockerRegistryConnection: 'gcr-tutorial'
        imageName: '$(DockerImageName):$(Build.BuildId)'
    - task: Docker@0
      displayName: 'Publish image'
      inputs:
        containerregistrytype: 'Container Registry'
        dockerRegistryConnection: 'gcr-tutorial'
        action: 'Push an image'
        imageName: '$(DockerImageName):$(Build.BuildId)'
    
  3. Confirme as alterações e envie-as para o Azure Pipelines:

    Visual Studio

    1. Abra o Team Explorer e clique no ícone Home na parte superior esquerda para trocar para a visualização Home.
    2. Clique em Changes.
    3. Insira uma mensagem de confirmação como Extend build definition to build Docker image.
    4. Clique em Confirmar tudo e enviar por push.

    Linha de comando

    1. Organize todos os arquivos modificados:

      git add -A
      
    2. Confirme as alterações no repositório local:

      git commit -m "Extend build definition to build Docker image"
      
    3. Envie as alterações para o Azure DevOps:

      git push
      
  4. No menu do Azure DevOps, selecione Pipelines.

    Uma nova compilação será acionada automaticamente. Pode levar cerca de dois minutos para que a compilação seja concluída. Pode levar cerca de dois minutos para a compilação ser concluída.

  5. Para verificar se a imagem foi publicada no Container Registry, mude para o Console do Cloud, selecione Container Registry > Imagens e clique em musicstore.

    Uma única imagem e a tag desta imagem são exibidas. A tag corresponde ao ID numérico da compilação executada no Azure Pipelines.

Como implantar continuamente

Agora que o Azure Pipelines está compilando automaticamente seu código e publicando imagens do Docker para cada commit, retorne sua atenção para a implantação.

Ao contrário de alguns outros sistemas de integração contínua, o Azure Pipelines distingue entre criação e implantação e fornece um conjunto especializado de ferramentas chamado Gerenciamento de versões para todas as tarefas relacionadas à implantação.

O Gerenciamento de versões do Azure Pipelines é criado com base nestes conceitos:

  • Uma versão se refere a um conjunto de artefatos que compõem uma versão específica do app e que geralmente é o resultado de um processo de compilação.
  • Implantação refere-se ao processo de escolher uma versão e implantá-la em um ambiente específico.
  • Uma implantação executa um conjunto de tarefas, que podem ser agrupadas em jobs.
  • Os estágios permitem segmentar seu pipeline e podem ser usados para orquestrar implantações em vários ambientes, por exemplo, ambientes de desenvolvimento e teste.

O principal artefato produzido pelo processo de compilação da MusicStore é a imagem do Docker. No entanto, como a imagem do Docker é publicada no Container Registry, ela está fora do escopo dos Pipelines do Azure. A imagem, portanto, não serve bem como a definição de uma versão.

Para implantar no Kubernetes, você também precisa de um manifesto, que se assemelha a uma lista de materiais. O manifesto não apenas define os recursos que o Kubernetes tem de criar e gerenciar, mas também especifica a versão exata da imagem do Docker a ser utilizada. O manifesto do Kubernetes é adequado para servir como o artefato que define a versão no gerenciamento de versões do Azure Pipelines.

Configurar a implantação do Kubernetes

Para executar a MusicStore no Kubernetes, você precisa dos recursos a seguir:

  • Uma implantação que defina um único pod que executa a imagem do Docker produzida pela compilação.
  • Um serviço NodePort que torne o pod acessível a um balanceador de carga.
  • Uma entrada que exponha o aplicativo à Internet pública usando um balanceador de carga HTTP(S) do Cloud.

Com o aplicativo MusicStore, é possível usar o SQL Server ou um banco de dados interno armazenado localmente. Por uma questão de simplicidade, use a configuração padrão que depende do banco de dados incorporado, por mais que ela tenha duas restrições:

  • Somente uma única cópia do pod pode ser executada por vez. Caso contrário, os usuários poderão ver dados diferentes dependendo de qual pod os disponibiliza.
  • Todas as alterações de dados são perdidas sempre que o pod é reiniciado, a menos que você altere a implantação para usar volumes permanentes. Não cobrimos esse cenário no tutorial.

Para definir esses recursos do Kubernetes, execute as seguintes etapas:

  1. Abra deployment.yaml e cole o seguinte código e, em seguida, salve o arquivo:

    apiVersion: v1
    kind: Service
    metadata:
      name: musicstore
    spec:
      ports:
      - port: 80
        targetPort: 8080
        protocol: TCP
        name: http
      selector:
        app: musicstore
      type: NodePort
    
    ---
    apiVersion: extensions/v1beta1
    kind: Ingress
    metadata:
      name: musicstore
    spec:
      backend:
        serviceName: musicstore
        servicePort: 80
    
    ---
    apiVersion: extensions/v1beta1
    kind: Deployment
    metadata:
      name: musicstore
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            app: musicstore
        spec:
          containers:
          - name: musicstore
            image: MUSICSTORE_IMAGE
            ports:
              - containerPort: 8080
            livenessProbe:      # Used by deployment controller
              httpGet:
                path: /
                port: 8080
              initialDelaySeconds: 5
              periodSeconds: 5
            readinessProbe:     # Used by Ingress/GCLB
              httpGet:
                path: /
                port: 8080
              initialDelaySeconds: 3
              periodSeconds: 5
            resources:
              limits:
                memory: 1024Mi
              requests:
                memory: 768Mi
    
  2. Confirme as alterações e envie-as para o Azure Pipelines:

    Visual Studio

    1. Abra o Team Explorer e clique no ícone Home na parte superior esquerda para trocar para a visualização Home.
    2. Clique em Changes.
    3. Insira uma mensagem de confirmação como Add Kubernetes manifest.
    4. Clique em Confirmar tudo e enviar por push.

    Linha de comando

    1. Organize todos os arquivos modificados:

      git add -A
      
    2. Confirme as alterações no repositório local:

      git commit -m "Add Kubernetes manifest"
      
    3. Envie as alterações para o Azure DevOps:

      git push
      

Configurar os ambientes de desenvolvimento e produção

Antes de retornar ao gerenciamento de versões do Azure Pipelines, você precisa criar os clusters do GKE.

Criar clusters do GKE

  1. Volte para a instância do Cloud Shell.

  2. Ative a API GKE no projeto:

    gcloud services enable container.googleapis.com
  3. Crie o cluster de desenvolvimento usando o comando a seguir. Observe que esse processo pode levar alguns minutos para ser concluído:

    gcloud container clusters create azure-pipelines-cicd-dev
  4. Crie o cluster de produção usando o comando a seguir. Observe que esse processo pode levar alguns minutos para ser concluído:

    gcloud container clusters create azure-pipelines-cicd-prod

Conectar o Azure Pipelines ao cluster de desenvolvimento

Assim como o Azure Pipelines pode ser usado para se conectar a um registro do Docker externo, como o Container Registry, ele também oferece suporte à integração de clusters Kubernetes externos.

É possível autenticar no Container Registry usando uma conta de serviço do Google Cloud, mas o uso de contas de serviço do Google Cloud não é compatível com o Azure Pipelines para autenticação com o GKE. Em vez disso, você precisa usar uma conta de serviço do Kubernetes.

Para conectar o Azure Pipelines ao seu cluster de desenvolvimento, é preciso primeiro criar uma conta de serviço do Kubernetes.

  1. No Cloud Shell, conecte-se ao cluster de desenvolvimento:

    gcloud container clusters get-credentials azure-pipelines-cicd-dev
  2. Crie uma conta de serviço do Kubernetes para o Azure Pipelines:

    kubectl create serviceaccount azure-pipelines-deploy
  3. Atribua o papel cluster-admin à conta de serviço criando uma vinculação de papel de cluster:

    kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy
  4. Determine o endereço IP do cluster:

    gcloud container clusters describe azure-pipelines-cicd-dev --format=value\(endpoint\)
    

    Você precisará desse endereço daqui a pouco.

  5. No menu do Azure DevOps, selecione Project settings e, em seguida, Pipelines > Service connections.

  6. Clique em New service connection.

  7. Selecione Kubernetes e clique em Avançar.

  8. Defina as configurações a seguir.

    • Método de autenticação: Conta de serviço.
    • URL do servidor: https://[PRIMARY_IP]/. Substitua [PRIMARY_IP] pelo endereço IP que você determinou anteriormente.
    • Secret: execute o comando a seguir no Cloud Shell e copie a saída:
      kubectl get secret $(kubectl get serviceaccounts azure-pipelines-deploy -o custom-columns=":secrets[0].name") -o yaml
    • Nome da conexão de serviço: azure-pipelines-cicd-dev.
  9. Clique em Save.

Conectar o Azure Pipelines ao cluster de produção

Para conectar o Azure Pipelines ao seu cluster de produção, siga a mesma abordagem.

  1. No Cloud Shell, conecte-se ao cluster de produção:

    gcloud container clusters get-credentials azure-pipelines-cicd-prod
  2. Crie uma conta de serviço do Kubernetes para o Azure Pipelines:

    kubectl create serviceaccount azure-pipelines-deploy
  3. Atribua o papel cluster-admin à conta de serviço criando uma vinculação de papel de cluster:

    kubectl create clusterrolebinding azure-pipelines-deploy --clusterrole=cluster-admin --serviceaccount=default:azure-pipelines-deploy
  4. Determine o endereço IP do cluster:

    gcloud container clusters describe azure-pipelines-cicd-prod --format=value\(endpoint\)
    

    Você precisará desse endereço daqui a pouco.

  5. No menu do Azure DevOps, selecione Project settings e, em seguida, Pipelines > Service connections.

  6. Clique em New service connection.

  7. Selecione Kubernetes e clique em Avançar.

  8. Defina as configurações a seguir:

    • Método de autenticação: Conta de serviço.
    • URL do servidor: https://[PRIMARY_IP]/. Substitua [PRIMARY_IP] pelo endereço IP que você determinou anteriormente.
    • Secret: execute o comando a seguir no Cloud Shell e copie a saída:
      kubectl get secret $(kubectl get serviceaccounts azure-pipelines-deploy -o custom-columns=":secrets[0].name") -o yaml
    • Nome da conexão de serviço: azure-pipelines-cicd-prod.
  9. Clique em Save.

Configurar o pipeline de lançamento

Depois de configurar a infraestrutura do GKE, você retorna ao Azure Pipelines para automatizar a implantação, o que inclui estas tarefas:

  • Implantação no ambiente de desenvolvimento
  • Solicitação de aprovação manual antes de iniciar uma implantação no ambiente de produção
  • Implantação no ambiente de produção

Criar uma definição de versão

Como primeiro passo, crie uma nova definição de versão.

  1. No menu do Azure DevOps, selecione Pipelines > Releases.
  2. Clique em New pipeline.
  3. Na lista de modelos, selecione Job vazio.
  4. Quando for necessário inserir um nome para o estágio, digite Dev.
  5. Na parte superior da tela, nomeie a versão MusicStore-KubernetesEngine.
  6. No diagrama de pipeline, ao lado de Artifacts, clique em Add.
  7. Selecione Build e adicione as seguintes configurações:

    • Tipo de origem: Build
    • Origem (pipeline de build): selecione a definição da compilação. Haverá apenas uma opção
    • Versão padrão: Latest
    • Alias de origem: manifest
  8. Clique em Add.

  9. Na caixa Artifact, clique em Continuous deployment trigger (ícone de raio) para adicionar um gatilho de implantação.

  10. Em Continuous deployment trigger, defina a chave como Enabled.

  11. Clique em Salvar.

  12. Insira um comentário se quiser e clique em Save para confirmar.

    O pipeline será assim:

    Captura de tela do pipeline atualizado no Azure Pipelines

Implantar no cluster de desenvolvimento

Depois de criar a definição de versão, você pode configurar a implantação no cluster de desenvolvimento do GKE.

  1. No menu, alterne para a guia Tasks.
  2. Clique em Agent job.
  3. Defina Agent specification para ubuntu-18.04.
  4. Ao lado de Agent job, clique em Add a task to agent job para adicionar uma etapa à fase.
  5. Selecione a tarefa Deploy to Kubernetes e clique em Add.
  6. Clique na tarefa recém-adicionada e defina as seguintes configurações:

    • Nome de exibição: Deploy
    • Ação: implantação
    • Conexão de serviço Kubernetes: azure-pipelines-cicd-dev
    • Namespace: default
    • Estratégia: nenhuma
    • Manifestos: manifest/drop/deployment.yaml
  7. Clique em Salvar.

  8. Insira um comentário se quiser e clique em OK para confirmar.

Implantar no cluster de produção

Por fim, configure a implantação no cluster de produção do GKE.

  1. No menu, passe para a guia Pipeline.
  2. Na caixa Stages, select Add > New stage.
  3. Na lista de modelos, selecione Job vazio.
  4. Quando for necessário inserir um nome para o estágio, digite Production.
  5. Clique no ícone de raio, referente ao cenário recém-criado.
  6. Defina as configurações a seguir:

    • Select trigger: After stage
    • Stages: Dev
    • Pre-deployment approvals: (ativada)
    • Approvers: selecione seu próprio nome de usuário

    O pipeline agora fica assim:

    Captura de tela do pipeline atualizado no Azure Pipelines

  7. Alterne para a guia Tasks.

  8. Mantenha o mouse sobre a guia Tasks e clique em Tasks > Production.

  9. Clique em Agent job.

  10. Defina Agent specification para ubuntu-18.04.

  11. Clique em Add a task to agent job para adicionar uma etapa à fase.

  12. Selecione a tarefa Deploy to Kubernetes e clique em Add.

  13. Clique na tarefa recém-adicionada e defina as seguintes configurações:

    • Nome de exibição: Deploy
    • Ação: implantação
    • Conexão de serviço Kubernetes: azure-pipelines-cicd-prod
    • Namespace: default
    • Estratégia: nenhuma
    • Manifestos: manifest/drop/deployment.yaml
  14. Clique em Salvar.

  15. Insira um comentário se quiser e clique em OK para confirmar.

Executar o pipeline

Agora que você configurou o pipeline inteiro, é possível testá-lo executando uma alteração no código-fonte:

  1. No computador local, abra o arquivo samples\MusicStore\config.json no repositório Git que você clonou anteriormente.
  2. Na linha 3, altere a configuração SiteTitle para ASP.NET MVC Music Store on Kubernetes Engine.
  3. Confirme as alterações e envie-as para o Azure Pipelines.

    Visual Studio

    1. Abra o Team Explorer e clique no ícone Home.
    2. Clique em Changes.
    3. Insira uma mensagem de confirmação como Change site title.
    4. Clique em Confirmar tudo e enviar por push.

    Linha de comando

    1. Organize todos os arquivos modificados:

      git add -A
      
    2. Confirme as alterações no repositório local:

      git commit -m "Change site title"
      
    3. Envie as alterações para o Azure Pipelines:

      git push
      
  4. No menu do Azure DevOps, selecione Pipelines. Um build é acionada.

  5. Após a conclusão do build, selecione Pipelines > Releases. Um processo de versão será iniciado.

  6. Clique em Release-1 para abrir a página de detalhes e aguarde até que o status do estágio Development mude para Succeeded.

  7. No Console do Cloud, selecione Kubernetes Engine > Serviços & Entrada.

  8. Localize o serviço Ingress para o cluster azure-pipelines-cicd-dev e aguarde até que o status dele mude para Ok. Isso pode levar alguns minutos.

  9. Abra o link na coluna Endpoints da mesma linha. Talvez você veja um erro no início porque o balanceador de carga leva alguns minutos para ficar disponível. Quando estiver pronto, observe que a Music Store foi implantada e está usando o título personalizado:

    Captura de tela mostrando o aplicativo Music Store em execução em uma página do navegador

  10. No Azure Pipelines, clique no botão Approve abaixo do cenário Prod, para promover a implantação no ambiente de produção:

    Captura de tela mostrando a página da versão e uma mensagem &quot;Uma aprovação de pré-implantação está pendente... Aprovar ou Rejeitar&quot;

    Se você não encontrar o botão, talvez seja necessário aprovar ou rejeitar uma versão anterior.

  11. Insira um comentário, se quiser, e clique em Approve para confirmar.

  12. Aguarde o status do ambiente Prod passar para Succeeded. Pode ser necessário atualizar manualmente a página no navegador.

  13. No Console do Cloud, atualize a página Serviços.

  14. Localize o serviço Ingress para o cluster azure-pipelines-cicd-prod e aguarde que o status dele mude para Ok. Isso pode levar alguns minutos.

  15. Abra o link na coluna Endpoints da mesma linha. Novamente, talvez você veja um erro no início porque o balanceador de carga leva alguns minutos para ficar disponível. Quando estiver pronto, você verá o aplicativo MusicStore com o título personalizado novamente, desta vez em execução no cluster de produção.

Limpeza

Para evitar custos adicionais depois de concluir este tutorial, exclua as entidades criadas.

Excluir o projeto do Azure Pipelines

Para excluir o projeto do Azure Pipelines, consulte a documentação de serviços do Azure DevOps. A exclusão do projeto do Azure Pipelines faz com que todas as alterações no código-fonte sejam perdidas.

Excluir os projetos de desenvolvimento e produção do Google Cloud

  1. No Console do Cloud, acesse a página Gerenciar recursos:

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

A seguir