Como criar um pipeline de CI/CD com o Azure Pipelines e o Google Kubernetes Engine

Neste tutorial, você aprende a usar o Azure Pipelines, anteriormente chamado de Visual Studio Team Services, o Google Kubernetes Engine (GKE) e o Container Registry para criar um pipeline de integração/implantação contínuas (CI/CD, na sigla em inglês). É usado o aplicativo da Web ASP.NET MusicStore, que é baseado no ASP.NET Core (em inglês).

O canal de CI/CD usa dois clusters separados do GKE, um para teste e outro para produção. No início do canal, 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. O diagrama a seguir ilustra esse processo:

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

Para o tutorial, pressupõe-se que você tenha conhecimentos básicos de .NET Core, Azure Pipelines e GKE. Você precisa também ter acesso administrativo a uma conta do Azure DevOps e a uma instalação do Visual Studio 2017 que esteja conectada à sua conta do Azure DevOps.

Objetivos

  • Conectar o Container Registry ao Azure Pipelines para publicar imagens do Docker.
  • Preparar um aplicativo de amostra .NET Core (em inglês) 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, há componentes do Google Cloud Platform passíveis de cobrança, inclusive estes:

Use a Calculadora de preços para gerar uma estimativa de custo com base no uso previsto. Para saber quais taxas podem ser aplicadas ao uso do Azure DevOps, verifique a página de preços dele (em inglês).

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, na sigla em inglês) 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. Selecione ou crie um projeto do Google Cloud Platform.

    Acessar a página Gerenciar recursos

  2. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  3. Certifique-se de ter uma conta Azure DevOps e de 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.
  4. Verifique se você tem o Visual Studio 2017 instalado e se está conectado à sua conta do Azure DevOps.

Como criar um projeto do Azure DevOps

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

  1. Acesse a home page do Azure DevOps (https://dev.azure.com/[YOUR_AZURE_DEVOPS_ACCOUNT_NAME]).
  2. Clique em Create Project.
  3. Insira um nome de projeto, como Music Store.
  4. Defina Visibility como Private e clique em Create project.
  5. Após a criação do projeto, clique em Repos, no menu à esquerda.
  6. Clique em Import para bifurcar o repositório MusicStore do GitHub. Defina os seguintes valores:

    • Source type: Git
    • Clone URL: https://github.com/aspnet/MusicStore.git
    • Deixe a caixa de seleção Requires authorization desmarcada.

    Captura de tela da caixa de diálogo "Import a Git repository"

  7. Clique em Import.

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

Como fazer compilação contínua

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.

Criar um branch de testes

Este tutorial foi criado e testado com a versão 2.0.0 do aplicativo Music Store. Para garantir que você esteja usando a mesma versão, crie um novo branch com base na tag rel/2.0.0:

  1. No menu do Azure DevOps, selecione Repos > Tags.
  2. Na lista de tags, expanda rel e, em seguida, clique com o botão direito do mouse no ícone ao lado de 2.0.0.
  3. Selecione New branch.
  4. Insira testing como o nome do branch e clique em Create branch para confirmar as seleções.

    Captura de tela da caixa de diálogo "Create a branch" no Azure Pipelines

Por padrão, o Azure Pipelines espera que seu código resida no branch master. Para que seja usada a ramificação de testing, você precisa alterar o branch 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 agências.
  5. Selecione o branch de teste.

    O botão ... aparecerá ao lado do nome dele.

  6. Clique em ... e selecione Set as default branch.

Como criar o código

Depois de criar o branch, comece a automatizar a compilação. Como o MusicStore é um aplicativo ASP.NET Core, a compilação 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 da compilação

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.

Como finalizar o projeto no Visual Studio

Para criar um arquivo YAML que defina o pipeline de compilação, primeiro confira o código.

  1. No Visual Studio, abra o Team Explorer.
  2. No menu, clique no ícone Manage Connections.
  3. Selecione Manage Connections > Connect to a Project.

    Captura de tela da opção "Conectar-se a um Projeto" no painel Team Explorer do Visual Studio

  4. Na caixa de diálogo seguinte, selecione o repositório Git Music Store e clique em Clonar.

    Captura de tela do repositório Git "Music Store" selecionado na caixa de diálogo "Conectar-se a um Projeto" no Visual Studio

Como criar um arquivo YAML que define o pipeline de compilação

Com o código verificado, configure o pipeline de compilação.

  1. No Visual Studio, abra o Solution Explorer.
  2. Na raiz da solução, crie um arquivo chamado azure-pipelines.yml.
  3. Copie o código a seguir e cole-o no arquivo:

    resources:
    - repo: self
      fetchDepth: 1
    queue:
      name: Hosted Ubuntu 1604
    trigger:
    - testing
    variables:
      TargetFramework: 'netcoreapp2.0'
      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
    
  4. Na seção variables, substitua [PROJECT_ID] pelo nome do projeto do GCP e salve o arquivo.

  5. Abra o Team Explorer e clique no ícone Página Inicial na parte superior esquerda para trocar para a visualização de Página Inicial.

  6. Clique em Changes.

  7. Digite uma mensagem de confirmação, como Add build definition.

  8. Clique em Commit All and Push.

  9. No menu do Azure DevOps, selecione Pipelines > Builds.

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

Como publicar imagens do Docker

Para implantar o aplicativo MusicStore no GKE, você precisa empacotá-lo como um contêiner do Docker e publicá-lo no Container Registry. Agora você estenderá a definição da compilação para automatizar essas etapas.

Como configurar uma conta de serviço para publicar imagens

A conexão com o Container Registry requer que o Azure Pipelines possa se autenticar com o GCP. Para isso, crie uma conta de serviço no GCP dedicada a essa finalidade.

  1. Alterne para seu projeto no Console do GCP e abra o Cloud Shell.

    Abrir o Cloud Shell

  2. 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. Basta executar 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 você não tiver certeza sobre qual zona escolher, use us-central1-a.

    Por exemplo:

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

    gcloud services enable containerregistry.googleapis.com
  4. 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"
  5. Atribua o papel de IAM do Storage Admin à conta de serviço:

    PROJECT_NUMBER=$(gcloud projects describe \
        $(gcloud config get-value core/project) \
        --format='value(projectNumber)')
    
    AZURE_PIPELINES_PUBLISHER=$(gcloud iam service-accounts list \
        --filter="displayName:Azure Pipelines Publisher" \
        --format='value(email)')
    
    gcloud projects add-iam-policy-binding \
        $(gcloud config get-value core/project) \
        --member serviceAccount:$AZURE_PIPELINES_PUBLISHER \
        --role roles/storage.admin
    
  6. 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
  7. Clique no botão no canto superior direito do Cloud Shell para abrir o Code Editor:

    Captura de tela do ícone "Ativar o editor de código" na barra de menus do Cloud Shell

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

Com a conta de serviço criada, conecte o Azure Pipelines ao Container Registry.

  1. No menu do Azure DevOps, selecione Project settings e, em seguida, Pipelines > Service connections.
  2. Clique em New service connection.
  3. Na lista, selecione Docker Registry.
  4. Na caixa de diálogo, insira valores para os seguintes campos:

    • Connection Name: gcr-tutorial
    • Docker Registry: https://gcr.io/[PROJECT-ID], em que [PROJECT-ID] é o nome do projeto do GCP

      Por exemplo: https://gcr.io/azure-pipelines-test-project-12345

    • Docker ID: _json_key

    • Password: cole o conteúdo de azure-pipelines-publisher-oneline.json

  5. Clique em OK para criar a conexão.

Como criar um Dockerfile

  1. No Visual Studio, abra o Gerenciador de Soluções.
  2. Na raiz da solução, crie um arquivo chamado Dockerfile.
  3. Copie o código a seguir, cole no arquivo e salve-o:

    FROM microsoft/aspnetcore:2.0.0
    WORKDIR /app
    COPY samples/MusicStore/bin/Release/netcoreapp2.0/publish /app/
    ENTRYPOINT ["dotnet", "MusicStore.dll"]
  4. Na raiz da solução, crie um novo arquivo chamado deployment.yaml. Deixe o arquivo vazio por enquanto.

  5. Abra o Team Explorer e clique no ícone Página Inicial na parte superior esquerda para trocar para a visualização de Página Inicial.

  6. Clique em Alterações.

  7. Digite uma mensagem de confirmação, como Add Dockerfile and placeholder for the Kubernetes manifest.

  8. Clique em Commit All.

Como estender a definição da 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. No Visual Studio, abra 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)'
    

Para confirmar e enviar as alterações para o Azure DevOps, faça o seguinte:

  1. No Visual Studio, abra o Team Explorer.
  2. Clique no ícone Início na parte superior esquerda para alternar para a visualização Início.
  3. Clique em Alterações.
  4. Digite uma mensagem de confirmação, como Extend build definition to build Docker image.
  5. Clique em Confirmar Tudo e Enviar por push.
  6. No menu do Azure DevOps, selecione Pipelines > Builds.

    Observe que uma nova compilação foi acionada automaticamente. Pode levar cerca de dois minutos para a compilação ser concluída.

    Se a compilação falhar e apresentar a mensagem de erro Step input dockerRegistryConnection references service connection gcr-tutorial which could not be found, talvez seja necessário salvar novamente o pipeline (em inglês).

  7. Para verificar se a imagem foi publicada no Container Registry, alterne para o Console do GCP, selecione Container Registry > Images e, em seguida, clique em musicstore.

    Observe que há uma única imagem e que a tag dessa imagem corresponde ao código numérico da compilação que foi executada no Azure Pipelines.

    Captura de tela da lista de imagens no Container Registry

Como fazer implantação contínua

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

Ao contrário de alguns outros sistemas de integração contínua, o Azure Pipelines faz distinção entre compilar e implantar, além de oferecer um conjunto especializado de ferramentas rotuladas como gerenciamento de versões para todas as tarefas relacionadas à implantação.

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

  • Uma versão se refere a um conjunto de artefatos que compõe uma versão específica do aplicativo e que geralmente é o resultado de um processo de compilação.
  • Implantação se refere 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 stages 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.

Como configurar a implantação do Kubernetes

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

  • 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. No Visual Studio, abra o Gerenciador de Soluções.
  2. Abra o arquivo deployment.yaml, cole o código a seguir nele e salve-o:

    apiVersion: v1
    kind: Service
    metadata:
      name: musicstore
    spec:
      ports:
      - port: 80
        targetPort: 80
        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: 80
            livenessProbe:      # Used by deployment controller
              httpGet:
                path: /
                port: 80
              initialDelaySeconds: 5
              periodSeconds: 5
            readinessProbe:     # Used by Ingress/GCLB
              httpGet:
                path: /
                port: 80
              initialDelaySeconds: 3
              periodSeconds: 5
            resources:
              limits:
                memory: 1024Mi
              requests:
                memory: 768Mi
    
  3. Abra o Team Explorer e alterne para a visualização Home.

  4. Clique em Alterações.

  5. Digite uma mensagem de confirmação, como Add Kubernetes manifest.

  6. Clique em Confirmar Tudo e Enviar por push.

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

Como criar clusters do GKE

  1. No GCP, abra uma instância do Cloud Shell.
  2. Para economizar tempo ao digitar suas opções de código de 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]

    Por exemplo:

    gcloud config set project azure-pipelines-test-project-12345
    gcloud config set compute/zone us-central1-a
  3. Ative a API do GKE no projeto:

    gcloud services enable container.googleapis.com
  4. 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
  5. 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-se no Container Registry usando uma conta de serviço do GCP, mas o Azure Pipelines não aceita essas contas 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 do 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 e selecione Kubernetes.

  7. Defina as configurações a seguir.

    • Choose authentication: Service account.
    • Connection name: azure-pipelines-cicd-dev.
    • Server URL: https://[MASTER-IP]/. Substitua [MASTER-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
  8. Clique em OK.

Como 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 do 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 e selecione Kubernetes.

  7. Defina as configurações a seguir:

    • Choose authentication: Service account.
    • Connection name: azure-pipelines-cicd-prod.
    • Server URL: https://[MASTER-IP]/. Substitua [MASTER-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
  8. Clique em OK.

Como configurar o canal de versões

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

Como 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 Empty job.
  4. Quando você for solicitado a fornecer um nome para o cenário, insira 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:

    • Source (build pipeline): selecione a definição da compilação. Haverá apenas uma opção
    • Default version: Latest
    • Source Alias: manifest
  8. Clique em Add.

  9. Na caixa Artifact, clique no ícone de raio para adicionar um acionador de implantação.

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

  11. Clique em Save.

  12. Insira um comentário, se quiser, e confirme clicando em Savej.

O pipeline agora fica assim:

Captura de tela do canal atualizado no Azure Pipelines

Como implantar o 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 do pipeline, alterne para a guia Tarefas.
  2. Clique em Agent job.
  3. Altere o "agent pool" para Hosted Ubuntu 1604.
  4. Ao lado de Agent job, clique no ícone + 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:

    • Display name: Deploy
    • Service connection type: Kubernetes Service Connection
    • Kubernetes service connection: azure-pipelines-cicd-dev
    • Command: apply
    • Use configuration: Enabled
    • Configuration type: File path
    • Configuration file: manifest/drop/deployment.yaml
  7. Clique em Save.

  8. Insira um comentário, se quiser, e confirme clicando em OK.

Como 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, selecione Add > New stage.
  3. Na lista de modelos, selecione Empty job.
  4. Quando você for solicitado a fornecer um nome para o cenário, insira Prod.
  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: (enabled)
    • Approvers: selecione seu próprio nome de usuário

    O pipeline agora fica assim:

    Captura de tela do canal atualizado no Azure Pipelines

  7. Alterne para a guia Tasks.

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

  9. Clique em Agent job.

  10. Altere o "Agent pool" para Hosted Ubuntu 1604.

  11. Clique no ícone + 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:

    • Display name: Deploy
    • Service connection type: Kubernetes Service Connection
    • Kubernetes service connection: azure-pipelines-cicd-prod
    • Command: apply
    • Use configuration: Enabled
    • Configuration type: File path
    • Configuration file: manifest/drop/deployment.yaml
  14. Clique em Save.

  15. Insira um comentário, se quiser, e confirme clicando em OK.

Como executar o canal

Agora que você configurou todo o canal, é hora de testá-lo executando uma alteração no código-fonte.

  1. No Visual Studio, abra o arquivo samples\MusicStore\config.json.
  2. Na linha 3, altere a configuração SiteTitle para ASP.NET MVC Music Store running on Google Kubernetes Engine.
  3. Abra o Team Explorer e alterne para a visualização Home.
  4. Clique em Alterações.
  5. Digite uma mensagem de confirmação, como Change site title.
  6. Clique em Confirmar Tudo e Enviar por push.
  7. No menu do Azure DevOps, selecione Pipelines > Builds e observe que uma compilação foi acionada automaticamente:

    Captura de tela mostrando a lista de compilações a caminho, com a compilação do armazenamento de música em andamento

    Pode levar cerca de dois minutos para que o status indique êxito.

  8. Quando a compilação estiver concluída, selecione Pipelines > Releases e observe que um processo de versão foi iniciado:

    Captura de tela mostrando que o processo de versão foi iniciado

  9. Clique em Release-1 para abrir a página de detalhes e aguarde até que o status do stage Dev mude para Succeeded. Pode ser necessário atualizar o status clicando no botão Refresh no menu ou recarregando a página do navegador.

  10. No Console do GCP, selecione Kubernetes Engine > Serviços.

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

  12. Copie o URL do link com o rótulo */* na mesma linha e remova o asterisco à direita.

  13. Abra o URL em uma nova guia do navegador. 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

  14. 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 de versão e uma mensagem "A pre-deployment approval is pending... Approve or Reject"

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

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

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

  17. No Console do GCP, atualize a página Serviços.

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

  19. Copie o URL do link com o rótulo */* na mesma linha e remova o asterisco à direita.

  20. Abra o URL em uma nova guia do navegador. 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.

Limpar

Para evitar custos extras depois de concluir este tutorial, exclua as entidades que você criou.

Excluir o projeto do Azure Pipelines

Exclua o projeto no Azure Pipelines. Observe que isso também causa a perda de todas as alterações no código-fonte.

Excluir o projeto do GCP

  1. No Console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione um e clique em Excluir projeto.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

A seguir

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

Enviar comentários sobre…