Implementación en Azure App Service mediante Azure Pipelines

1. Inicie sesión en su organización de Azure DevOps y vaya a su proyecto.

2. Vaya a Canalizaciones y seleccione Nueva canalización.

3. Cuando se le solicite, seleccione la ubicación del código fuente: Azure Repos Git o GitHub.

   Puede que se le redirija a GitHub para iniciar sesión. Si es así, escriba sus credenciales de GitHub.

4. Cuando aparezca la lista de repositorios, seleccione el que corresponda.

5. Es posible que se le redirija a GitHub para instalar la aplicación Azure Pipelines. Si es así, seleccione Aprobar e instalar.

6. Cuando aparezca la pestaña Configurar, seleccione ASP.NET Core.

7. Cuando aparezca la nueva canalización, eche un vistazo al archivo YAML para ver lo que hace. Cuando esté listo, seleccione Guardar y ejecutar.

Primeros pasos:

1. Cree una canalización y seleccione la plantilla ASP.NET Core. Esta selección agrega automáticamente las tareas necesarias para compilar el código en el repositorio de ejemplo.

2. Guarde la canalización y ponga en cola una compilación para verla en acción.

   La plantilla de canalización ASP.NET Core publica el archivo ZIP de implementación como un artefacto de Azure para la tarea de implementación más adelante.

1. Seleccione el final del archivo YAML y, a continuación, seleccione Mostrar asistente.

2. Usa el Asistente de tareas para agregar la tarea aplicación web de Azure.

   Como alternativa, puede agregar la tarea de implementación AzureRmWebAppDeploymentde Azure App Service.

3. Elija la suscripción de Azure. Asegúrese de seleccionar Autorizar para autorizar la conexión. La autorización crea la conexión de servicio necesaria.

4. Seleccione el tipo de aplicación, el nombre de aplicación y la pila de tiempo de ejecución en función de la aplicación de App Service. El código YAML completo debe tener un aspecto similar al siguiente.

   variables:
     buildConfiguration: 'Release'
   
   steps:
   - task: DotNetCoreCLI@2
     inputs:
       command: 'publish'
       publishWebProjects: true
   - task: AzureWebApp@1
     inputs:
       azureSubscription: '<service-connection-name>'
       appType: 'webAppLinux'
       appName: '<app-name>'
       package: '$(System.DefaultWorkingDirectory)/**/*.zip'
   

   • azureSubscription: nombre de la conexión de servicio autorizada a la suscripción de Azure.
   • appName: nombre de la aplicación existente.
   • package: ruta de acceso de archivo al paquete o una carpeta que contiene el contenido de App Service. Se admite caracteres comodín.

Primeros pasos:

1. Cree una pipeline de liberación. Seleccione Versiones en el menú de la izquierda y seleccione Nueva canalización.

2. Seleccione la plantilla de la implementación de Azure App Service para la fase. Este paso agrega automáticamente las tareas necesarias.

   Nota:

   Si va a implementar una aplicación de Node.js en App Service en Windows, seleccione la plantilla Aplicación implementada Node.js en Azure App Service . La única diferencia entre estas plantillas es que la plantilla de Node.js configura la tarea para generar un web.config archivo que contiene un parámetro que inicia el iisnode servicio.

3. Para vincular esta canalización de versión al artefacto de Azure desde el paso anterior, seleccione Agregar un artefacto>Compilación.

4. En Origen (canalización de compilación), seleccione la canalización de compilación que creó en la sección anterior. A continuación, seleccione Agregar.

5. Guarde la canalización de versión y cree una versión para verla en acción.

Para implementar un paquete web de .zip (por ejemplo, desde una aplicación web de ASP.NET) en una aplicación web de Azure, use el siguiente fragmento de código para implementar la compilación en una aplicación.

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
- task: AzureWebApp@1
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: 'webAppLinux'
    appName: '<app-name>'
    package: '$(System.DefaultWorkingDirectory)/**/*.zip'

• azureSubscription: su suscripción de Azure.
• appType: tipo de aplicación web.
• appName: nombre del servicio de aplicaciones existente.
• package: ruta de acceso de archivo al paquete o una carpeta que contiene el contenido de App Service. Se admite caracteres comodín.

En el caso de las canalizaciones clásicas, es más fácil definir las fases de compilación y versión en paneles independientes (canalizaciones y versiones, respectivamente).

• En la página Canalizaciones, compile y pruebe la aplicación mediante la plantilla que prefiera, como ASP.NET Core, Node.js con Grunt, Maven u otras, y publique un artefacto. Publique un artefacto.
• En el panel Publicación, use una plantilla genérica de implementación de Azure App Service para implementar el artefacto.

Puede haber plantillas para lenguajes de programación específicos entre los que elegir.

De forma predeterminada, la implementación se produce en la aplicación raíz de la aplicación web de Azure. Puede implementar en una aplicación virtual específica mediante la propiedad VirtualApplication de la tarea implementación de Azure App Service (AzureRmWebAppDeployment):

- task: AzureRmWebAppDeployment@4
  inputs:
    VirtualApplication: '<name of virtual application>'

• VirtualApplication: el nombre de la aplicación virtual configurada en Azure Portal. Para obtener más información, vea Configurar una aplicación de App Service en Azure Portal.

De forma predeterminada, la implementación se produce en la aplicación raíz de la aplicación web de Azure. Si desea realizar la implementación en una aplicación virtual específica, escriba su nombre en la propiedad Aplicación virtual de la tarea Implementación de Azure App Service.

El siguiente ejemplo muestra cómo implementar en un espacio de ensayo y, a continuación, cambiar a un espacio de producción:

- task: AzureWebApp@1
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: webAppLinux
    appName: '<app-name>'
    deployToSlotOrASE: true
    resourceGroupName: '<name of resource group>'
    slotName: staging
    package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: '<service-connection-name>'
    appType: webAppLinux
    WebAppName: '<app-name>'
    ResourceGroupName: '<name of resource group>'
    SourceSlot: staging
    SwapWithProduction: true

• azureSubscription: su suscripción de Azure.
• appType: (Opcional) Use webAppLinux para implementar en una aplicación web en Linux.
• appName: nombre del servicio de aplicaciones existente.
• deployToSlotOrASE*: Bbooleano. implementar en una ranura de implementación existente o en un Azure App Service Environment.
• resourceGroupName: nombre del grupo de recursos. Es necesario si deployToSlotOrASE es verdadero.
• slotName: nombre de la ranura, que tiene productioncomo valor predeterminado . Es necesario si deployToSlotOrASE es verdadero.
• package: ruta de acceso de archivo al paquete o una carpeta que contiene el contenido de App Service. Se admite caracteres comodín.
• SourceSlot: ranura enviada a producción cuando SwapWithProduction es true.
• SwapWithProduction: Bbooleano. Intercambiar el tráfico de la ranura de origen con producción.

Use la opción Implementar en la ranura o en App Service Environment en la tarea de aplicación web de Azure para especificar la ranura en la que debe implementarse. Para intercambiar las ranuras, use la tarea Administrar Azure App Service.

Puede usar trabajos en el archivo YAML para configurar una canalización de implementaciones. Mediante trabajos, puede controlar el orden de implementación en varias aplicaciones web.

jobs:
- job: buildandtest
  pool:
    vmImage: ubuntu-latest
 
  steps:
  # publish an artifact called drop
  - task: PublishPipelineArtifact@1
    inputs:
      targetPath: '$(Build.ArtifactStagingDirectory)' 
      artifactName: drop
  
  # deploy to Azure Web App staging
  - task: AzureWebApp@1
    inputs:
      azureSubscription: '<service-connection-name>'
      appType: <app type>
      appName: '<staging-app-name>'
      deployToSlotOrASE: true
      resourceGroupName: <group-name>
      slotName: 'staging'
      package: '$(Build.ArtifactStagingDirectory)/**/*.zip'

- job: deploy
  dependsOn: buildandtest
  condition: succeeded()

  pool: 
    vmImage: ubuntu-latest  
  
  steps:
    # download the artifact drop from the previous job
  - task: DownloadPipelineArtifact@2
    inputs:
      source: 'current'
      artifact: 'drop'
      path: '$(Pipeline.Workspace)'

  - task: AzureWebApp@1
    inputs:
      azureSubscription: '<service-connection-name>'
      appType: <app type>
      appName: '<production-app-name>'
      resourceGroupName: <group-name>
      package: '$(Pipeline.Workspace)/**/*.zip'

Si desea implementar en varias aplicaciones web, agregue fases a la canalización de versión. Puede controlar el orden de implementación. Para más información, consulte Fases.

Para implementar condicionalmente en YAML, puede usar una de las técnicas siguientes:

• Aísle los pasos de implementación en un trabajo independiente y agregue una condición a ese trabajo.
• Agregue una condición al paso.

En el ejemplo siguiente se muestra cómo usar condiciones de paso para implementar solamente compilaciones que se originan en la rama principal:

- task: AzureWebApp@1
  condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main'))
  inputs:
    azureSubscription: '<service-connection-name>'
    appName: '<app-name>'

Para más información sobre condiciones, consulte Especificación de condiciones.

En tu pipeline de lanzamiento, puedes implementar varias comprobaciones y condiciones para gestionar la implementación:

• Establezca filtros de rama para configurar el desencadenador de implementación continua en el artefacto de la canalización de versión.
• Establezca aprobaciones previas a la implementación o configure puertas como condición previa para la implementación en una fase.
• Especifique las condiciones de una tarea que se va a ejecutar.

Para más información, consulte Desencadenadores de versión, rama y fase, Control de implementación de versiones mediante aprobaciones, Control de implementación de versión mediante puertas y Especificación de condiciones para ejecutar una tarea.

trigger:
- main

pool:
  vmImage: windows-latest

variables:
  buildConfiguration: 'Release'

steps:
- task: DotNetCoreCLI@2
  inputs:
    command: 'publish'
    publishWebProjects: true
    arguments: '--configuration $(buildConfiguration)'
    zipAfterPublish: true
- task: AzureRmWebAppDeployment@4
  inputs:
    ConnectionType: 'AzureRM'
    azureSubscription: '<service-connection-name>'
    appType: 'webApp'
    WebAppName: '<app-name>'
    packageForLinux: '$(System.DefaultWorkingDirectory)/**/*.zip'
    enableCustomDeployment: true
    DeploymentType: 'webDeploy'

En la canalización de versión, suponiendo que usa la plantilla implementación de Azure App Service:

1. Seleccione la pestaña Tareas y, después, implementar Azure App Service (la AzureRmWebAppDeployment tarea).

2. En el cuadro de diálogo, asegúrese de que Tipo de conexión esté establecido en Azure Resource Manager.

3. En el cuadro de diálogo, expanda Opciones de implementación adicionales y elija Seleccionar método de implementación. Asegúrese de que Web Deploy esté seleccionado como método de implementación.

4. Guarde la canalización de versión.