Delen via

Toepassingsimplementaties automatiseren in Azure Spring Apps

Notitie

De Basic, Standarden Enterprise--plannen zijn op 17 maart 2025 buiten gebruik gesteld. Zie de aankondiging over buitengebruikstelling van Azure Spring Apps voor meer informatie.

Dit artikel is van toepassing op:✅ Basic/Standard ✅ Enterprise

In dit artikel leest u hoe u de Azure Spring Apps-taak voor Azure Pipelines gebruikt om toepassingen te implementeren.

Met de hulpprogramma's voor continue integratie en continue levering kunt u snel updates implementeren voor bestaande toepassingen met minimale inspanning en risico. Met Azure DevOps kunt u deze belangrijke taken ordenen en beheren.

In de volgende video wordt end-to-end automatisering beschreven met behulp van hulpprogramma's van uw keuze, waaronder Azure Pipelines.


Een Azure Resource Manager-serviceverbinding maken

Maak eerst een Azure Resource Manager-serviceverbinding met uw Azure DevOps-project. Zie Verbinding maken met Microsoft Azure voor instructies. Zorg ervoor dat u hetzelfde abonnement selecteert dat u gebruikt voor uw Azure Spring Apps-service-exemplaar.

Apps bouwen en implementeren

U kunt nu uw projecten bouwen en implementeren met behulp van een reeks taken. De volgende Azure Pipelines-sjabloon definieert variabelen, een .NET Core-taak om de toepassing te bouwen en een Azure Spring Apps-taak om de toepassing te implementeren.

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)

Een Azure Spring Apps-exemplaar en een Azure DevOps-project instellen

Gebruik eerst de volgende stappen om een bestaand Azure Spring Apps-exemplaar in te stellen voor gebruik met Azure DevOps.

  1. Ga naar uw Azure Spring Apps-exemplaar en maak vervolgens een nieuwe app.
  2. Ga naar de Azure DevOps-portal en maak vervolgens een nieuw project onder uw gekozen organisatie. Als u geen Azure DevOps-organisatie hebt, kunt u er gratis een maken.
  3. Selecteer Opslagplaatsen en importeer vervolgens de Spring Boot-democode naar de opslagplaats.

Een Azure Resource Manager-serviceverbinding maken

Maak vervolgens een Azure Resource Manager-serviceverbinding met uw Azure DevOps-project. Zie Verbinding maken met Microsoft Azure voor instructies. Zorg ervoor dat u hetzelfde abonnement selecteert dat u gebruikt voor uw Azure Spring Apps-service-exemplaar.

Apps bouwen en implementeren

U kunt nu uw projecten bouwen en implementeren met behulp van een reeks taken. In de volgende secties ziet u verschillende opties voor het implementeren van uw app met behulp van Azure DevOps.

Implementeren met behulp van een pijplijn

Voer de volgende stappen uit om te implementeren met behulp van een pijplijn:

  1. Selecteer Pijplijnen en maak vervolgens een nieuwe pijplijn met een Maven-sjabloon.

  2. Bewerk het azure-pipelines.yml-bestand om het veld in te stellen op mavenPomFile.

  3. Selecteer Assistent weergeven aan de rechterkant en selecteer vervolgens de Azure Spring Apps-sjabloon .

  4. Selecteer de serviceverbinding die u hebt gemaakt voor uw Azure-abonnement en selecteer vervolgens uw Azure Spring Apps-exemplaar en app-exemplaar.

  5. Schakel Staging-implementatie uit.

  6. Stel Pakket of map in op compleet/doel/spring-boot-complete-0.0.1-SNAPSHOT.jar.

  7. Selecteer Toevoegen om deze taak toe te voegen aan uw pijplijn.

    De pijplijninstellingen moeten overeenkomen met de volgende afbeelding.

    Schermopname van Azure DevOps met de nieuwe pijplijninstellingen.

    U kunt uw projecten ook bouwen en implementeren met behulp van de volgende pijplijnsjabloon. In dit voorbeeld wordt eerst een Maven-taak gedefinieerd om de toepassing te bouwen, gevolgd door een tweede taak waarmee het JAR-bestand wordt geïmplementeerd met behulp van de Azure Spring Apps-taak voor 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. Selecteer Opslaan en uitvoeren en wacht tot de taak is voltooid.

Blauw-groene implementaties

De implementatie die in de vorige sectie wordt weergegeven, ontvangt direct toepassingsverkeer bij de implementatie. Hiermee kunt u de toepassing testen in de productieomgeving voordat het klantverkeer wordt ontvangen.

Het pijplijnbestand bewerken

Als u de toepassing op dezelfde manier wilt bouwen als eerder wordt weergegeven en deze wilt implementeren in een faseringsimplementatie, gebruikt u de volgende sjabloon. In dit voorbeeld moet de faseringsimplementatie al bestaan. Zie Blauwgroene implementatiestrategieën voor een alternatieve aanpak.

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

De sectie Releases gebruiken

In de volgende stappen ziet u hoe u een blauwgroene implementatie inschakelt vanuit de sectie Releases .

  1. Selecteer Pijplijnen en maak een nieuwe pijplijn voor uw Maven-build en publiceer artefact.

    1. Selecteer Azure Repos Git voor uw codelocatie.
    2. Selecteer een opslagplaats waar uw code zich bevindt.
    3. Selecteer de Maven-sjabloon en wijzig het bestand om het veld in te stellen op mavenPomFile.
    4. Selecteer Assistent weergeven aan de rechterkant en selecteer de sjabloon Buildartefacten publiceren.
    5. Stel pad om te publiceren in op complete/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.
    6. Selecteer Opslaan en uitvoeren.

  2. Selecteer Releases en maak vervolgens een release.

  3. Voeg een nieuwe pijplijn toe en selecteer Lege taak om deze aan te maken.

  4. Selecteer bij Fasen de regel 1 job, 0 taak

    Schermopname van Azure DevOps die het tabblad Pijplijnen laat zien met de link 1 taak, 0 taken, gemarkeerd.

    1. Selecteer de + om een taak aan de opdracht toe te voegen.
    2. Zoek de Azure Spring Apps-sjabloon en selecteer Toevoegen om de taak toe te voegen.
    3. Selecteer Azure Spring Apps Deploy: om de taak te bewerken.
    4. Vul deze taak in met de gegevens van uw app en schakel vervolgens Faseringsimplementatie gebruiken uit.
    5. Schakel Een nieuwe faseringsimplementatie maken in als deze niet bestaat en voer een naam in Implementatie in.
    6. Selecteer Opslaan om deze taak op te slaan.
    7. Selecteer OK.

  5. Selecteer Pijplijn en selecteer vervolgens Een artefact toevoegen.

    1. Selecteer onder Bron (build-pijplijn) de pijplijn die u eerder hebt gemaakt.
    2. Selecteer Toevoegen en vervolgens Opslaan.

  6. Selecteer 1 taak, 1 taak onder Fasen.

  7. Navigeer naar de taak Azure Spring Apps-implementatie in Fase 1, en selecteer vervolgens het beletselteken naast Pakket of map.

  8. Selecteer spring-boot-complete-0.0.1-SNAPSHOT.jar in het dialoogvenster en selecteer VERVOLGENS OK.

    Schermopname van Azure DevOps met het dialoogvenster Een bestand of map selecteren.

  9. Selecteer de + optie om een andere Azure Spring Apps-taak aan de taak toe te voegen.

  10. Wijzig de actie in Productie-implementatie instellen.

  11. Selecteer Opslaan en maak vervolgens een release om de implementatie automatisch te starten.

Als u de huidige releasestatus van uw app wilt controleren, selecteert u Release weergeven. Nadat deze taak is voltooid, gaat u naar Azure Portal om de status van uw app te controleren.

Implementeren vanuit bron

Als u rechtstreeks naar Azure wilt implementeren zonder een afzonderlijke buildstap, gebruikt u de volgende pijplijnsjabloon.

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

Implementeren vanuit aangepaste afbeelding

Om direct vanaf een bestaande containerimage te implementeren, gebruikt u de volgende pijplijnsjabloon.

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

Een builder implementeren en specificeren (alleen voor enterprise-abonnement)

Als u het Azure Spring Apps Enterprise-plan gebruikt, kunt u ook opgeven welke opbouwfunctie moet worden gebruikt voor het implementeren van acties met behulp van de builder optie, zoals wordt weergegeven in het volgende voorbeeld. Zie Tanzu Build Service gebruiken voor meer informatie.

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

Volgende stappen

  • Last updated on