Partilhar via

Automatize implantações de aplicativos no Azure Spring Apps

  • Artigo

Nota

Os planos Basic, Standard e Enterprise serão preteridos a partir de meados de março de 2025, com um período de aposentadoria de 3 anos. Recomendamos a transição para os Aplicativos de Contêiner do Azure. Para obter mais informações, consulte o anúncio de aposentadoria do Azure Spring Apps.

O plano de consumo padrão e dedicado será preterido a partir de 30 de setembro de 2024, com um desligamento completo após seis meses. Recomendamos a transição para os Aplicativos de Contêiner do Azure. Para obter mais informações, consulte Migrar consumo padrão e plano dedicado do Azure Spring Apps para Aplicativos de Contêiner do Azure.

Este artigo aplica-se a: ✔️ Basic/Standard ✔️ Enterprise

Este artigo mostra como usar a tarefa Azure Spring Apps para Azure Pipelines para implantar aplicativos.

As ferramentas de integração contínua e entrega contínua permitem que você implante rapidamente atualizações em aplicativos existentes com o mínimo de esforço e risco. O Azure DevOps ajuda você a organizar e controlar esses trabalhos importantes.

O vídeo a seguir descreve a automação de ponta a ponta usando ferramentas de sua escolha, incluindo o Azure Pipelines.


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

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

Criar e implementar aplicações

Agora você pode criar e implantar seus projetos usando uma série de tarefas. O modelo Azure Pipelines a seguir define variáveis, uma tarefa .NET Core para criar 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 existente do Azure Spring Apps para uso com o Azure DevOps.

  1. Vá para sua instância do Azure Spring Apps e crie um novo aplicativo.
  2. Vá para o portal de DevOps do Azure e crie um novo projeto na 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 com seu projeto do Azure DevOps. Para obter instruções, consulte Conectar-se ao Microsoft Azure. Certifique-se de selecionar a mesma assinatura que você está usando para sua instância de serviço do Azure Spring Apps.

Criar e implementar aplicações

Agora você pode criar 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 crie um novo pipeline com um modelo Maven.

  2. Edite o arquivo azure-pipelines.yml para definir o mavenPomFile campo 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 sua instância do Azure Spring Apps e a instância do aplicativo.

  5. Desative Usar implantação de preparo.

  6. Defina Pacote ou pasta para completar/destino/spring-boot-complete-0.0.1-SNAPSHOT.jar.

  7. Selecione Adicionar para adicionar esta tarefa ao seu pipeline.

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

    Captura de tela do Azure DevOps que mostra as novas configurações de pipeline.

    Você também pode criar e implantar seus projetos usando o seguinte modelo de pipeline. Este exemplo primeiro define uma tarefa Maven para criar o aplicativo, seguida por uma segunda tarefa que implanta 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 aguarde a conclusão do trabalho.

Implantações azul-verde

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

Editar o arquivo de pipeline

Para criar o aplicativo da mesma maneira mostrada anteriormente e implantá-lo em uma implantação de preparo, use o modelo a seguir. Neste exemplo, a implantação de preparo já deve existir. Para uma abordagem alternativa, consulte Estratégias de implantação verde-azul.

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

Use a seção Lançamentos

As etapas a seguir mostram como habilitar uma implantação azul-verde na seção Versões .

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

    1. Selecione Azure Repos Git para seu local de código.
    2. Selecione um repositório onde seu código está localizado.
    3. Selecione o modelo Maven e modifique o arquivo para definir o mavenPomFile campo como complete/pom.xml.
    4. Selecione Mostrar assistente no lado direito e selecione o modelo Publicar artefatos de compilação.
    5. Defina Caminho a ser publicado para completar/destino/spring-boot-complete-0.0.1-SNAPSHOT.jar.
    6. Selecione Guardar 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 o trabalho da linha 1, a tarefa 0

    Captura de ecrã do Azure DevOps que mostra o separador Pipelines com a ligação 1 trabalho, 0 tarefa realçada.

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

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

    1. Em Origem (pipeline de construção), selecione o pipeline criado anteriormente.
    2. Selecione Adicionar e, em seguida , Guardar.

  6. Selecione 1 trabalho, 1 tarefa em Estágios.

  7. Navegue até a tarefa Implantar do Azure Spring Apps 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, em seguida, selecione OK.

    Captura de ecrã do Azure DevOps que mostra a caixa de diálogo Selecionar um ficheiro ou pasta.

  9. Selecione a + opçã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 da versão atual do seu aplicativo, selecione Exibir versão. Depois que essa tarefa for concluída, visite o portal do Azure para verificar o status do seu aplicativo.

Implantar a partir da origem

Para implantar diretamente no Azure sem uma etapa de compilação separada, use o seguinte modelo de pipeline.

- 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 a partir de imagem personalizada

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

- 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 do Azure Spring Apps Enterprise, também poderá especificar qual construtor usar para ações de implantação usando a builder opção, 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>'

Próximos passos