Automatizzare le distribuzioni di applicazioni in Azure Spring Apps

Nota

I piani Basic, Standard ed Enterprise saranno deprecati a partire dalla metà di marzo 2025, con un periodo di ritiro di 3 anni. È consigliabile eseguire la transizione ad App Azure Container. Per altre informazioni, vedere l'annuncio di ritiro di Azure Spring Apps.

Il piano Standard a consumo e dedicato sarà deprecato a partire dal 30 settembre 2024, con un arresto completo dopo sei mesi. È consigliabile eseguire la transizione ad App Azure Container. Per altre informazioni, vedere Eseguire la migrazione del consumo di Azure Spring Apps Standard e del piano dedicato alle app Azure Container.

Questo articolo si applica a: ✔️ Basic/Standard ✔️ Enterprise

Questo articolo illustra come usare l'attività Azure Spring Apps per Azure Pipelines per distribuire le applicazioni.

gli strumenti di integrazione continua e recapito continuo consentono di distribuire rapidamente aggiornamenti alle applicazioni esistenti con il minimo sforzo e rischio. Azure DevOps consente di organizzare e controllare questi processi chiave.

Il video seguente descrive l'automazione end-to-end usando strumenti di propria scelta, tra cui Azure Pipelines.

Creare una connessione al servizio Azure Resource Manager

Creare prima di tutto una connessione al servizio Azure Resource Manager al progetto Azure DevOps. Per istruzioni, vedere Connettersi a Microsoft Azure. Assicurarsi di selezionare la stessa sottoscrizione usata per l'istanza del servizio Azure Spring Apps.

Compilare e distribuire app

È ora possibile compilare e distribuire i progetti usando una serie di attività. Il modello di Azure Pipelines seguente definisce le variabili, un'attività .NET Core per compilare l'applicazione e un'attività di Azure Spring Apps per distribuire l'applicazione.

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)

Configurare un'istanza di Azure Spring Apps e un progetto Azure DevOps

Prima di tutto, usare la procedura seguente per configurare un'istanza di Azure Spring Apps esistente da usare con Azure DevOps.

1. Passare all'istanza di Azure Spring Apps e quindi creare una nuova app.
2. Passare al portale di Azure DevOps e quindi creare un nuovo progetto nell'organizzazione scelta. Se non si dispone di un'organizzazione Azure DevOps, è possibile crearne una gratuitamente.
3. Selezionare Repos e quindi importare il codice demo spring boot nel repository.

Creare una connessione al servizio Azure Resource Manager

Creare quindi una connessione al servizio Azure Resource Manager al progetto Azure DevOps. Per istruzioni, vedere Connettersi a Microsoft Azure. Assicurarsi di selezionare la stessa sottoscrizione usata per l'istanza del servizio Azure Spring Apps.

Compilare e distribuire app

È ora possibile compilare e distribuire i progetti usando una serie di attività. Le sezioni seguenti illustrano varie opzioni per la distribuzione dell'app con Azure DevOps.

Eseguire la distribuzione con una pipeline

Per eseguire la distribuzione tramite una pipeline, seguire questa procedura:

1. Selezionare Pipeline, quindi creare una nuova pipeline con un modello Maven.

2. Modificare il file azure-pipelines.yml per impostare il mavenPomFile campo su "complete/pom.xml".

3. Selezionare Mostra assistente sul lato destro e quindi selezionare il modello Azure Spring Apps.

4. Selezionare la connessione al servizio creata per la sottoscrizione di Azure, quindi selezionare l'istanza di Azure Spring Apps e l'istanza dell'app.

5. Disabilitare Usa distribuzione di staging.

6. Impostare Pacchetto o cartella per completare/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.

7. Selezionare Aggiungi per aggiungere questa attività alla pipeline.

   Le impostazioni della pipeline devono corrispondere all'immagine seguente.

   

   È anche possibile compilare e distribuire i progetti usando il modello di pipeline seguente. Questo esempio definisce prima un'attività Maven per compilare l'applicazione, seguita da una seconda attività che distribuisce il file JAR usando l'attività Azure Spring Apps per 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. Selezionare Salva ed esegui, quindi attendere il completamento del processo.

Distribuzioni blu-verde

La distribuzione illustrata nella sezione precedente riceve il traffico dell'applicazione immediatamente dopo la distribuzione. In questo modo è possibile testare l'applicazione nell'ambiente di produzione prima di ricevere il traffico dei clienti.

Modificare il file della pipeline

Per compilare l'applicazione come illustrato in precedenza e distribuirla in una distribuzione di staging, usare il modello seguente. In questo esempio, la distribuzione di staging deve esistere già. Per un approccio alternativo, vedere Strategie di distribuzione blu-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

Usare la sezione Versioni

I passaggi seguenti illustrano come abilitare una distribuzione blu-verde dalla sezione Versioni .

1. Selezionare Pipeline e creare una nuova pipeline per la compilazione e la pubblicazione di Maven.

   1. Selezionare Azure Repos Git per il percorso del codice.
   2. Selezionare un repository in cui si trova il codice.
   3. Selezionare il modello Maven e modificare il file per impostare il mavenPomFile campo su complete/pom.xml.
   4. Selezionare Mostra assistente sul lato destro e selezionare il modello Pubblica artefatti di compilazione.
   5. Impostare Percorso per la pubblicazione per completare/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.
   6. Seleziona Salva ed Esegui.

2. Selezionare Versioni e quindi Crea versione.

3. Aggiungere una nuova pipeline e selezionare Processo vuoto per creare un processo.

4. In Fasi selezionare il processo riga 1, 0 attività

   

   1. Selezionare per aggiungere un'attività + al processo.
   2. Cercare il modello Di Azure Spring Apps e quindi selezionare Aggiungi per aggiungere l'attività al processo.
   3. Selezionare Azure Spring Apps Deploy (Distribuisci app Di Azure Spring): per modificare l'attività.
   4. Compilare questa attività con le informazioni dell'app, quindi disabilitare Usa distribuzione di staging.
   5. Abilitare Crea una nuova distribuzione di staging, se non esiste, quindi immettere un nome in Distribuzione.
   6. Selezionare Salva per salvare questa attività.
   7. Seleziona OK.

5. Selezionare Pipeline e quindi Aggiungi un artefatto.

   1. In Origine (pipeline di compilazione) selezionare la pipeline creata in precedenza.
   2. Selezionare Aggiungi, quindi Salva.

6. Selezionare 1 processo, 1 attività in Fasi.

7. Passare all'attività Distribuzione di App Spring di Azure nella fase 1, quindi selezionare i puntini di sospensione accanto a Pacchetto o cartella.

8. Selezionare spring-boot-complete-0.0.1-SNAPSHOT.jar nella finestra di dialogo, quindi selezionare OK.

   

9. Selezionare per + aggiungere un'altra attività di Azure Spring Apps al processo.

10. Modificare l'azione impostando La distribuzione di produzione.

11. Selezionare Salva, quindi Crea versione per avviare automaticamente la distribuzione.

Per verificare lo stato corrente della versione dell'app, selezionare Visualizza versione. Al termine dell'attività, visitare il portale di Azure per verificare lo stato dell'app.

Eseguire la distribuzione dall'origine

Per eseguire la distribuzione direttamente in Azure senza un passaggio di compilazione separato, usare il modello di pipeline seguente.

- 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)

Eseguire la distribuzione da un'immagine personalizzata

Per eseguire la distribuzione direttamente da un'immagine del contenitore esistente, usare il modello di pipeline seguente.

- 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>'

Distribuire e specificare un generatore (solo piano Enterprise)

Se si usa il piano Azure Spring Apps Enterprise, è anche possibile specificare il generatore da usare per distribuire le azioni usando l'opzione builder , come illustrato nell'esempio seguente. Per altre informazioni, vedere Usare il servizio di compilazione Tanzu.

- 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>'

Passaggi successivi

• Avvio rapido: Distribuire la prima app Spring Boot in Azure Spring Apps