Automatizar implantações de aplicativos no Azure Spring Apps

Criar uma conexão de serviço do Azure Resource Manager

Primeiro, crie uma conexão de serviço do Azure Resource Manager para seu projeto do Azure DevOps. Para obter instruções, consulte Conectar ao Microsoft Azure. Escolha a mesma assinatura que você está usando para sua instância de serviço do Azure Spring Apps.

Compilar e implantar aplicativos

Agora você pode compilar e implantar seus projetos usando uma série de tarefas. O modelo do Azure Pipelines abaixo define variáveis, uma tarefa do .NET Core para compilar o aplicativo e uma tarefa do Azure Spring Apps para implantar o aplicativo.

variables:
  workingDirectory: './steeltoe-sample'
  planetMainEntry: 'Microsoft.Azure.SpringCloud.Sample.PlanetWeatherProvider.dll'
  solarMainEntry: 'Microsoft.Azure.SpringCloud.Sample.SolarSystemWeather.dll'
  planetAppName: 'planet-weather-provider'
  solarAppName: 'solar-system-weather'
  serviceName: '<your service name>'

steps:
# Restore, build, publish and package the zipped planet app
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: false
    arguments: '--configuration Release'
    zipAfterPublish: false
    modifyOutputPath: false
    workingDirectory: $(workingDirectory)

# Deploy the planet app
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<Service Connection Name>'
    Action: 'Deploy'
    AzureSpringCloud: $(serviceName)
    AppName: 'testapp'
    DeploymentType: 'Artifacts'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: $(workingDirectory)/src/$(planetAppName)/publish-deploy-planet.zip
    RuntimeVersion: 'NetCore_31'
    DotNetCoreMainEntryPath: $(planetMainEntry)

# Deploy the solar app
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<Service Connection Name>'
    Action: 'Deploy'
    AzureSpringCloud: $(serviceName)
    AppName: 'testapp'
    DeploymentType: 'Artifacts'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: $(workingDirectory)/src/$(solarAppName)/publish-deploy-solar.zip
    RuntimeVersion: 'NetCore_31'
    DotNetCoreMainEntryPath: $(solarMainEntry)

Configurar uma instância do Azure Spring Apps e um projeto do Azure DevOps

Primeiro, use as etapas a seguir para configurar uma instância do Azure Spring Apps existente para uso com o Azure DevOps.

1. Vá para sua instância do Azure Spring Apps e, em seguida, crie um novo aplicativo.
2. Vá para o portal do Azure DevOps e, em seguida, crie um novo projeto em sua organização escolhida. Se você não tiver uma organização do Azure DevOps, poderá criar uma gratuitamente.
3. Selecione Repositórios e, em seguida, importe o código de demonstração do Spring Boot para o repositório.

Criar uma conexão de serviço do Azure Resource Manager

Em seguida, crie uma conexão de serviço do Azure Resource Manager para seu projeto do Azure DevOps. Para obter instruções, consulte Conectar ao Microsoft Azure. Escolha a mesma assinatura que você está usando para sua instância de serviço do Azure Spring Apps.

Compilar e implantar aplicativos

Agora você pode compilar e implantar seus projetos usando uma série de tarefas. As seções a seguir mostram várias opções para implantar seu aplicativo usando o Azure DevOps.

Implantar usando um pipeline

Para implantar usando um pipeline, siga estas etapas:

1. Selecione Pipelines e, em seguida, crie um novo pipeline com um modelo Maven.

2. Edite o arquivo azure-pipelines.yml para definir o campo mavenPomFile como 'complete/pom.xml'.

3. Selecione Mostrar assistente no lado direito e, em seguida, selecione o modelo Azure Spring Apps.

4. Selecione a conexão de serviço que você criou para sua Assinatura do Azure e, em seguida, selecione a instância do Azure Spring Apps e a instância do aplicativo.

5. Desabilite Usar a Implantação de Preparo.

6. Defina o Pacote ou pasta como complete/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.

7. Selecione Adicionar para adicionar essa tarefa ao pipeline.

   As configurações do pipeline devem corresponder com a imagem a seguir.

   

   Você também pode criar e implantar seus projetos usando o modelo de pipeline a seguir. Primeiro, esse exemplo define uma tarefa Maven para compilar o aplicativo. Depois, define uma tarefa para implantar o arquivo JAR usando a tarefa Azure Spring Apps para Azure Pipelines.

   steps:
   - task: Maven@3
     inputs:
       mavenPomFile: 'complete/pom.xml'
   - task: AzureSpringCloud@0
     inputs:
       azureSubscription: '<your service connection name>'
       Action: 'Deploy'
       AzureSpringCloud: <your Azure Spring Apps service>
       AppName: <app-name>
       DeploymentType: 'Artifacts'
       UseStagingDeployment: false
       DeploymentName: 'default'
       Package: ./target/your-result-jar.jar
   

8. Selecione Salvar e executar e, em seguida, aguarde a finalização do trabalho.

Implantações azul-verde

A implantação mostrada na seção anterior recebe imediatamente o tráfego do aplicativo após a implantação. Isso permite que você teste o aplicativo no ambiente de produção antes de receber qualquer tráfego do cliente.

Edite o arquivo de pipeline

Para criar o aplicativo da maneira mostrada anteriormente e implantá-lo em uma implantação de preparo, use o modelo abaixo. Neste exemplo, a implantação de preparo já deve existir. Para conhecer outra técnica, confira Estratégias de implantação azul-verde.

steps:
- task: Maven@3
  inputs:
    mavenPomFile: 'pom.xml'
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Deploy'
    AzureSpringCloud: <your Azure Spring Apps service>
    AppName: <app-name>
    DeploymentType: 'Artifacts'
    UseStagingDeployment: true
    Package: ./target/your-result-jar.jar
- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Set Production'
    AzureSpringCloud: <your Azure Spring Apps service>
    AppName: <app-name>
    UseStagingDeployment: true

Usar a seção Versões

As etapas a seguir mostram como habilitar uma implantação "blue-green" na seção Versões.

1. Selecione Pipelines e crie um novo pipeline para o artefato de compilação e publicação do Maven.

   1. Selecione Git do Azure Repos para o local do código.
   2. Selecione um repositório no qual seu código está localizado.
   3. Selecione o modelo Maven e modifique o arquivo para definir o campo mavenPomFile como complete/pom.xml.
   4. Selecione Mostrar assistente no lado direito e selecione o modelo Publicar artefatos de compilação.
   5. Defina o Caminho para publicar como complete/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.
   6. Selecione Salvar e executar.

2. Selecione Versões e, em seguida, Criar versão.

3. Adicione um novo pipeline e selecione Trabalho vazio para criar um trabalho.

4. Em Estágios, selecione a linha 1 trabalho, 0 tarefa

   

   1. Selecione o + para adicionar uma tarefa ao trabalho.
   2. Pesquise pelo modelo Azure Spring Apps e, em seguida, selecione Adicionar para adicionar a tarefa ao trabalho.
   3. Selecione Azure Spring Apps Implantar: para editar a tarefa.
   4. Preencha essa tarefa com as informações do aplicativo e desabilite Usar Implantação de Preparo.
   5. Habilite Criar uma nova implantação de preparo se uma não existir e, em seguida, insira um nome em Implantação.
   6. Selecione Salvar para salvar essa tarefa.
   7. Selecione OK.

5. Selecione Pipeline e, em seguida, selecione Adicionar um artefato.

   1. Em Origem (pipeline de build) selecione o pipeline criado anteriormente.
   2. Escolha Adicionar e, depois, Salvar.

6. Selecione 1 trabalho, 1 tarefa emEstágios.

7. Navegue até a tarefa Azure Spring Apps Implantar no Estágio 1 e selecione as reticências ao lado de Pacote ou pasta.

8. Selecione spring-boot-complete-0.0.1-SNAPSHOT.jar na caixa de diálogo e selecione OK.

   

9. Selecione o + para adicionar outra tarefa do Azure Spring Apps ao trabalho.

10. Altere a ação para Definir Implantação de Produção.

11. Selecione Salvar e, em seguida, Criar versão para iniciar automaticamente a implantação.

Para verificar o status atual da versão do aplicativo, selecione Exibir versão. Depois que essa tarefa for concluída, visite o portal do Azure para verificar o status do aplicativo.

Implantar da origem

Para implantar diretamente no Azure sem uma etapa de build separada, use o modelo de pipeline a seguir.

- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Deploy'
    AzureSpringCloud: <your Azure Spring Apps service>
    AppName: <app-name>
    DeploymentType: 'Artifacts'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: $(Build.SourcesDirectory)

Implantar de imagem personalizada

Para implantar diretamente a partir de uma imagem de contêiner existente, use o modelo de pipeline a seguir.

- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your service connection name>'
    Action: 'Deploy'
    AzureSpringCloud: '<your Azure Spring Apps service>'
    AppName: '<app-name>'
    DeploymentType: 'CustomContainer'
    UseStagingDeployment: false
    DeploymentName: 'default'
    ContainerRegistry: 'docker.io'  # or your Azure Container Registry, e.g: 'contoso.azurecr.io'
    RegistryUsername: '$(username)'
    RegistryPassword: '$(password)'
    ContainerImage: '<your image tag>'

Implantar e especificar um construtor (somente plano Enterprise)

Se você estiver usando o plano Enterprise dos Aplicativos Spring do Azure, também poderá especificar qual construtor usar para implantar ações usando a opção builder, conforme mostrado no exemplo a seguir. Para obter mais informações, consulte Usar o Tanzu Build Service.

- task: AzureSpringCloud@0
  inputs:
    azureSubscription: '<your-service-connection-name>'
    Action: 'Deploy'
    AzureSpringCloud: '<your-Azure-Spring-Apps-service-instance-name>'
    AppName: '<app-name>'
    UseStagingDeployment: false
    DeploymentName: 'default'
    Package: './target/your-result-jar.jar'
    Builder: '<your-Tanzu-Build-Service-Builder-resource>'