Automatización de implementaciones de aplicaciones en Azure Spring Apps

  • Artículo

Nota:

Azure Spring Apps es el nuevo nombre del servicio Azure Spring Cloud. Aunque el servicio tiene un nuevo nombre, verá el nombre antiguo en algunos lugares durante un tiempo mientras trabajamos para actualizar recursos, como capturas de pantalla, vídeos y diagramas.

La información de este artículo puede ponerse en práctica en: ✔️ Básico o Estándar ✔️ Enterprise

En este artículo se muestra cómo usar la tarea de Azure Spring Apps para Azure Pipelines para implementar aplicaciones.

Las herramientas de integración continua y entrega continua permiten implementar rápidamente las actualizaciones en las aplicaciones existentes con el mínimo esfuerzo y riesgo. Azure DevOps ayuda a organizar y controlar estos trabajos clave.

En el vídeo siguiente se describe la automatización de un extremo a otro mediante las herramientas que prefiera, incluida Azure Pipelines.


Creación de una conexión de servicio de Azure Resource Manager

Primero, cree una conexión de servicio de Azure Resource Manager para el proyecto de Azure DevOps. Para obtener instrucciones, consulte Conexión a Microsoft Azure. Asegúrese de seleccionar la misma suscripción que usa para la instancia de servicio de Azure Spring Apps.

Compilación e implementación de aplicaciones

Ya puede compilar e implementar los proyectos mediante una serie de tareas. La siguiente plantilla de Azure Pipelines define variables, una tarea de .NET Core para compilar la aplicación y una tarea de Azure Spring Apps para implementarla.

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)

Configuración de una instancia Azure Spring Apps y un proyecto de Azure DevOps

En primer lugar, siga estos pasos para configurar una instancia de Azure Spring Apps existente para usarla con Azure DevOps.

  1. Vaya a la instancia de Azure Spring Apps y, a continuación, cree una aplicación nueva.
  2. Vaya al portal de Azure DevOps y, a continuación, cree un proyecto en la organización elegida. Si no tiene una organización de Azure DevOps, puede crear una gratis.
  3. Seleccione Repositorio y, a continuación, importe el código de demostración de Spring Boot en el repositorio.

Creación de una conexión de servicio de Azure Resource Manager

A continuación, cree una conexión de servicio de Azure Resource Manager para el proyecto de Azure DevOps. Para obtener instrucciones, consulte Conexión a Microsoft Azure. Asegúrese de seleccionar la misma suscripción que usa para la instancia de servicio de Azure Spring Apps.

Compilación e implementación de aplicaciones

Ya puede compilar e implementar los proyectos mediante una serie de tareas. En las secciones siguientes se muestran varias opciones para implementar la aplicación mediante Azure DevOps.

Implementación mediante una canalización

Para realizar una implementación mediante una canalización, siga estos pasos:

  1. Seleccione Canalizaciones y cree una nueva canalización con una plantilla de Maven.

  2. Edite el archivo azure-pipelines.yml para establecer el campo mavenPomFile en 'complete/pom.xml'.

  3. Seleccione la opción Mostrar el asistente que está a la derecha y, a continuación, seleccione la plantilla Azure Spring Apps.

  4. Seleccione la conexión de servicio que creó para la suscripción de Azure y, a continuación, seleccione la instancia de Azure Spring Apps y la instancia de la aplicación.

  5. Deshabilite la opción Usar implementación provisional.

  6. Establezca el valor de la opción Paquete o carpeta como complete/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.

  7. Seleccione Agregar para agregar esta tarea a la canalización.

    La configuración de la canalización debe coincidir con la siguiente imagen.

    Captura de pantalla de Azure DevOps que muestra la configuración de nueva canalización.

    También puede compilar e implementar los proyectos mediante la siguiente plantilla de canalización. En primer lugar, este ejemplo define una tarea de Maven para compilar la aplicación, seguida de una segunda tarea que implementa el archivo JAR mediante la tarea de 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. Seleccione Guardar y ejecutar y espere a que finalice el trabajo.

Implementaciones azul-verde

La implementación que se muestra en la sección anterior recibe inmediatamente el tráfico de la aplicación tras la implementación. Esto le permite probar la aplicación en el entorno de producción antes de recibir cualquier tráfico del cliente.

Edición del archivo de canalización

Para compilar la aplicación de la misma manera que se mostró anteriormente y agregarla a una implementación provisional, use la plantilla siguiente. En este ejemplo, la implementación de almacenamiento provisional ya debe existir. Para obtener un enfoque alternativo, consulte Estrategias de implementación 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

Uso de la sección Versiones

Los siguientes pasos le muestran cómo habilitar una implementación azul-verde desde la sección Versiones.

  1. Seleccione Canalizaciones y cree una nueva canalización para su artefacto de compilación y publicación de Maven.

    1. Seleccione el GIT de Azure Repos para obtener la ubicación del código.
    2. Seleccione el repositorio donde se encuentre el código.
    3. Seleccione la plantilla Maven y modifique el archivo para establecer el campo mavenPomFile en complete/pom.xml.
    4. Seleccione la opción Mostrar el asistente que está en el lado derecho y, a continuación, seleccione la plantilla Publicar artefactos de compilación.
    5. Establezca la Ruta de acceso para publicar como complete/target/spring-boot-complete-0.0.1-SNAPSHOT.jar.
    6. Seleccione Guardar y ejecutar.

  2. Seleccione Versiones y Crear versión.

  3. Agregue una nueva canalización y seleccione Trabajo vacío para crear un trabajo.

  4. En Fases, seleccione la línea 1 trabajo, 0 tarea

    Captura de pantalla de Azure DevOps que muestra la pestaña Canalizaciones con el vínculo de tarea 1, 0 resaltado.

    1. Seleccione + para agregar una tarea al trabajo.
    2. Busque la plantilla Azure Spring Apps y seleccione Agregar para agregar la tarea al trabajo.
    3. Seleccione Implementación de Azure Spring Apps: para editar la tarea.
    4. Complete la tarea con la información de la aplicación y deshabilite Usar implementación provisional.
    5. Habilite Crear una nueva implementación provisional si no existe una y escriba un nombre en Implementación.
    6. Seleccione Guardar para guardar la tarea.
    7. Seleccione Aceptar.

  5. Seleccione Canalización y, a continuación, seleccione Agregar un artefacto.

    1. En Origen (canalización de compilación), seleccione la canalización que creó anteriormente.
    2. Seleccione Aceptar y, a continuación, Guardar.

  6. Seleccione 1 trabajo, 1 tarea en Fases.

  7. Vaya a la tarea Implementación de Azure Spring Apps en la Fase 1 y seleccione los puntos suspensivos que están junto a la opción Paquete o carpeta.

  8. Seleccione spring-boot-complete-0.0.1-SNAPSHOT.jar en el cuadro de diálogo y, a continuación, seleccione Aceptar.

    Captura de pantalla de Azure DevOps que muestra el cuadro de diálogo Seleccionar un archivo o carpeta.

  9. Seleccione + para agregar otra tarea de Azure Spring Apps al trabajo.

  10. Cambie la acción a Establecer la implementación de producción.

  11. Seleccione Guardar y luego Crear versión para iniciar automáticamente la implementación.

Para comprobar el estado actual de la versión de la aplicación, seleccione Ver versión. Una vez finalizada esta tarea, visite Azure Portal para comprobar el estado de la aplicación.

Implementación desde el origen

Para realizar una implementación directamente en Azure sin tener que usar un paso de compilación independiente, use la siguiente plantilla de canalización.

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

Implementación a partir de una imagen personalizada

Para realizar la implementación directamente desde una imagen de contenedor existente, use la siguiente plantilla de canalización.

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

Implementación y especificación de un generador (solo plan Enterprise)

Si usa el plan Enterprise de Azure Spring Apps, también puede especificar qué generador usar para implementar acciones mediante la opción builder, como se muestra en el ejemplo siguiente. Para obtener más información, vea Usar el servicio de compilación de 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>'

Pasos siguientes