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

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

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

  • Conecte o Container Registry ao Azure Pipelines para publicar imagens do Docker.
  • Prepare um aplicativo de exemplo .NET Core para implantação no GKE.
  • Autentique-se com segurança no GKE sem precisar usar a autenticação legada.
  • Use 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, entre eles:

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

    Acessar a página Gerenciar recursos

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

    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

Você usa 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.
  5. Após a criação do projeto, clique em Repos, no menu à esquerda.
  6. Clique em Import para bifurcar o repositório Orchard CMS 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.

Como criar um branch de testes

Para garantir que as instruções neste tutorial funcionem, crie um branch do código baseado em uma versão específica do código-fonte. Isso ajudará a garantir que futuras mudanças no código no GitHub não invalidem este tutorial.

  1. No menu do Azure DevOps, selecione Repos > Tags.
  2. Na lista de tags, expanda rel e, em seguida, clique em 2.0.0.
  3. Selecione New branch.
  4. Insira testing como nome do branch e, em seguida, clique em Create branch para confirmar suas 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 Code > 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 compilar o código

Depois de criar o branch, você pode começar 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 unitários
  • 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.

  1. No menu Azure DevOps, selecione Pipelines > Builds e clique em New pipeline.
  2. Selecione Azure Repos como o local do código.
  3. Selecione o repositório Git que você importou anteriormente. Ele deve ter o mesmo nome do projeto do Azure DevOps.
  4. Selecione o Starter pipeline.
  5. Remova o código de exemplo gerado para azure-pipelines.yml e copie o seguinte código no editor:

    resources:
    - repo: self
      fetchDepth: 1
    queue:
      name: Hosted Ubuntu 1604
    variables:
      TargetFramework: 'netcoreapp2.0'
      RestoreBuildProjects: 'samples/**/*.csproj'
      TestProjects: 'test/MusicStore.Test/*.csproj'
      BuildConfiguration: 'Release'
      DockerImageName: '[PROJECT-NAME]/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
    

  6. Na seção variables, substitua [PROJECT_NAME] pelo nome do seu projeto do GCP.

  7. Clique em Save and run.
  8. Se quiser, digite uma mensagem de confirmação personalizada e clique em Save and run para confirmar.

    Isso confirma azure-pipelines.yml no branch de testing do repositório e aciona uma compilação. Quaisquer alterações adicionais na definição da compilação devem ser feitas com a alteração do arquivo 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 versã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 código de projeto e zona do Compute Engine, defina os valores de configuração padrão executando os seguintes comandos:

    gcloud config set project [PROJECT_NAME]
    gcloud config set compute/zone [ZONE]

    Substitua [PROJECT_NAME] pelo nome do seu projeto do GCP e substitua [ZONE] pelo nome da zona que você usará para criar recursos. Se você 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

  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 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 Editor de código:

    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.

Como conectar o Azure Pipelines ao Container Registry

Com a conta de serviço criada, você pode conectar 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-NAME], em que [PROJECT_NAME] é o nome do seu projeto do GCP.

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

    • Docker ID: _json_key

    • Password: o conteúdo de azure-pipelines-publisher-oneline.json
  5. Clique em OK para criar a conexão.

Como finalizar o projeto no Visual Studio

Para criar um Dockerfile que define o conteúdo da imagem do Docker, primeiro é necessário finalizar 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 "Connect to a Project" no painel Team Explorer do Visual Studio

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

    Captura de tela do repositório Git "Music Store" selecionado na caixa de diálogo "Connect to a Project" no Visual Studio

Como criar um Dockerfile

Com o código finalizado, configure o Dockerfile.

  1. No Visual Studio, abra o Solution Explorer.
  2. Na raiz da solução, crie um novo 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 Home na parte superior esquerda para alternar para a visualização Home.
  6. Clique em Changes.
  7. Insira 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 Changes.
  4. Insira uma mensagem de confirmação como Extend build definition to build Docker image.
  5. Clique em Commit All and Push.
  6. No menu do Azure DevOps, selecione Pipelines > Build.

    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 com a mensagem de erro Step input dockerRegistryConnection references service connection gcr-tutorial which could not be found, talvez seja necessário salvar novamente seu canal.

  7. Para verificar se a imagem foi publicada no Container Registry, alterne para o Console do GCP, selecione Container Registry > Imagens 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 é criado com base nestes conceitos:

  • Uma versão refere-se ao conjunto de artefatos que compõem uma versão específica do aplicativo e que geralmente resultam 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 stages permitem segmentar seu canal 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, você pode 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 abrangemos esse cenário no tutorial.

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

  1. No Visual Studio, abra o Solution Explorer.
  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 mude para a visualização Home.

  4. Clique em Changes.
  5. Insira uma mensagem de confirmação como Add Kubernetes manifest.
  6. Clique em Commit All and 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 seguintes comandos:

    gcloud config set project [PROJECT_NAME]
    gcloud config set compute/zone [ZONE]

    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

Como 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.
    • Token: execute o seguinte comando no Cloud Shell e copie a saída:
      kubectl get secret $(kubectl get secret -o custom-columns=":metadata.name" | grep azure-pipelines-deploy-) -o jsonpath="{.data.token}{'\n'}"
    • Certificate: execute o seguinte comando no Cloud Shell e copie a saída:
      kubectl get secret $(kubectl get secret -o custom-columns=":metadata.name" | grep azure-pipelines-deploy-) -o jsonpath="{.data['ca\.crt']}{'\n'}"
  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, você pode seguir 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.
    • Token: execute o seguinte comando no Cloud Shell e copie a saída:
      kubectl get secret $(kubectl get secret -o custom-columns=":metadata.name" | grep azure-pipelines-deploy-) -o jsonpath="{.data.token}{'\n'}"
    • Certificate: execute o seguinte comando no Cloud Shell e copie a saída:
      kubectl get secret $(kubectl get secret -o custom-columns=":metadata.name" | grep azure-pipelines-deploy-) -o jsonpath="{.data['ca\.crt']}{'\n'}"
  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 canal, ao lado de Artifacts, clique em Add.
  7. Selecione Build e adicione as seguintes configurações:

    • Source: selecione o repositório Git em que está o arquivo azure-pipelines.yml.
    • Default version: Latest
    • Source Alias: manifest
  8. Clique em Add.

  9. Na caixa Artefato, clique no ícone de raio para adicionar um acionador de implantação.
  10. Em Acionador de implantação contínua, defina a chave como Ativado.
  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 Kuberetes 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 files: Enabled
    • 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 ou grupo.

    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 Kuberetes 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 files: Enabled
    • 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 mude para a visualização Home.
  4. Clique em Changes.
  5. Insira uma mensagem de confirmação como Change site title.
  6. Clique em Commit All and Push.
  7. No menu do Azure DevOps, selecione Build and Release > 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 mude para Succeeded.

  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. Você pode ver 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 em Approve para promover a implantação para o 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 vir a barra amarela, talvez seja necessário primeiro aprovar ou recusar 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, você pode ver 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.

Como fazer a limpeza

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.

Próximas etapas

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

Enviar comentários sobre…