Implementación en App Service mediante Azure Pipelines

Azure DevOps Services | Azure DevOps Server 2020 | Azure DevOps Server 2019

Use Azure Pipelines para implementar automáticamente la aplicación web en Azure App Service en cada compilación correcta. Azure Pipelines permite compilar, probar e implementar con integración continua (CI) y entrega continua (CD) mediante Azure DevOps.

Las canalizaciones de YAML se definen mediante un archivo YAML en el repositorio. Un paso es el bloque de creación más pequeño de una canalización y puede ser un script o una tarea (script empaquetado previamente). Obtenga información sobre los conceptos y componentes clave que forma una canalización.

Usará la tarea Aplicación web de Azure (AzureWebApp) para implementar en Azure App Service en la canalización. En escenarios más complicados, p. ej., si necesita usar parámetros XML en la implementación, puede usar la tarea Implementación de Azure App Service (AzureRmWebAppDeployment).

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• Una organización de Azure DevOps. cree una de forma gratuita.
• Tener capacidad para ejecutar canalizaciones en agentes hospedados por Microsoft. Puede comprar un trabajo paralelo o solicitar un nivel gratuito.
• Una aplicación de Azure App Service funcional con código hospedado en GitHub o Azure Repos.
  • .NET: Creación de una aplicación web ASP.NET Core en Azure
  • ASP.NET: Creación de una aplicación web de ASP.NET Framework en Azure
  • JavaScript: Creación de una aplicación web de Node.js en Azure App Service
  • Java: Creación de una aplicación de Java en Azure App Service
  • Python: Creación de una aplicación de Python en Azure App Service

1. Creación de una canalización para su pila

En los ejemplos de código de esta sección, se supone que va a implementar una aplicación web ASP.NET. Puede adaptar las instrucciones para otros marcos.

Obtenga más información sobre la compatibilidad con el ecosistema de Azure Pipelines.

YAML

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.

Clásico

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.

2. Agregar la tarea de implementación

YAML

1. Haga clic en el final del archivo YAML y seleccione Mostrar asistente.

2. Use el Asistente de tareas para agregar la tarea Aplicación web de Azure.

   

   También puede agregar la tarea implementación de Azure App Service (AzureRmWebAppDeployment).

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

4. Seleccione el tipo de aplicación, nombre de aplicacióny runtime de pila 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:
   - script: dotnet build --configuration $(buildConfiguration)
     displayName: 'dotnet build $(buildConfiguration)'
   - 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 del archivo al paquete o una carpeta con el contenido del servicio de aplicaciones. Se admite caracteres comodín.

Clásico

Primeros pasos:

1. Cree una canalización de versión seleccionando Versiones en el menú de la izquierda y Nueva canalización.

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

   Nota:

   Si va a implementar una aplicación Node.js en App Service en Windows, seleccione la plantilla Implementar aplicación 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 archivo web.config que contiene un parámetro que inicia el servicio iisnode.

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 y, a continuación, seleccione Agregar.

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

Ejemplo: Implementación de una aplicación .NET

YAML

Para implementar un paquete web .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:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'
- 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 a Azure.
• appType: el tipo de aplicación web.
• appName: el nombre del servicio de aplicaciones existente.
• package: la ruta de acceso del archivo al paquete o una carpeta que contiene el contenido del servicio de aplicaciones. Se admite caracteres comodín.

Clásico

En el caso de las canalizaciones clásicas, lo más fácil es definir fases de compilación y versión en páginas independientes (Canalizaciones y Versiones respectivamente). En general, debe hacer lo siguiente:

• 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.
• En la página Versión, use la plantilla genérica implementación de Azure App Service para implementar el artefacto.

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

Ejemplo: Implementación en una aplicación virtual

YAML

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 que se ha configurado en Azure Portal. Para obtener más información, vea Configurar una aplicación de App Service en Azure Portal.

Clásico

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.

Ejemplo: Implementación en una ranura

YAML

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 a Azure.
• appType: (opcional) Use webAppLinux para implementar en una aplicación web en Linux.
• appName: el nombre del servicio de aplicaciones existente.
• deployToSlotOrASE: valor booleano para implementar en una ranura de implementación existente o en un Azure App Service Environment.
• resourceGroup: nombre del grupo de recursos. Es necesario si el valor de deployToSlotOrASE es true.
• slotName: Nombre de la ranura, que el valor predeterminado es production. Es necesario si el valor de deployToSlotOrASE es true.
• package: la ruta de acceso del archivo al paquete o una carpeta que contiene el contenido del servicio de aplicaciones. Se admite caracteres comodín.
• SourceSlot: ranura enviada a producción cuando el valor de SwapWithProduction es true.
• SwapWithProduction: valor booleano para intercambiar el tráfico de la ranura de origen con producción.

Clásico

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.

Ejemplo: Implementación en varias aplicaciones web

YAML

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'

Clásico

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.

Ejemplo: Sustituciones de variables

En la mayoría de las pilas de lenguaje, la configuración de la aplicación y las cadenas de conexión se pueden establecer como variables de entorno en tiempo de ejecución.

Pero hay otras razones por las que puede ser útil realizar sustituciones de variables en Web.config. En este ejemplo, el archivo Web.config contiene una cadena de conexión denominada connectionString. Puede cambiar su valor antes de implementar en cada aplicación web. Para ello, puede aplicar una transformación de Web.config o sustituir las variables en el archivo Web.config.

YAML

En el fragmento de código siguiente se muestra un ejemplo de sustitución de variables mediante la tarea Implementación de Azure App Service (AzureRmWebAppDeployment):

jobs:
- job: test
  variables:
    connectionString: <test-stage connection string>
  steps:
  - task: AzureRmWebAppDeployment@4
    inputs:
      azureSubscription: '<Test stage Azure service connection>'
      WebAppName: '<name of test stage web app>'
      enableXmlVariableSubstitution: true

- job: prod
  dependsOn: test
  variables:
    connectionString: <prod-stage connection string>
  steps:
  - task: AzureRmWebAppDeployment@4
    inputs:
      azureSubscription: '<Prod stage Azure service connection>'
      WebAppName: '<name of prod stage web app>'
      enableXmlVariableSubstitution: true

Clásico

Para cambiar connectionString mediante la sustitución de variables:

1. Cree una canalización de versión con dos fases.
2. Vincule el artefacto de la versión a la compilación que genera el paquete web.
3. Defina connectionString como una variable en cada una de las fases. Establezca el valor apropiado.
4. Seleccione la opción de sustitución de variables XML en Opciones de transformaciones de archivos y sustitución de variables en la tarea Implementación de Azure App Service.

Ejemplo: Implementación condicional

YAML

Para hacer esto en YAML, puede usar una de estas técnicas:

• 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.

Clásico

En la canalización de versión, puede implementar varias comprobaciones y condiciones para controlar 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 anteriores a la implementación como condición previa para la implementación en una fase.
• Configurar 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.

Ejemplo: Implementación mediante Web Deploy

La tarea de implementación de Azure App Service (AzureRmWebAppDeployment) puede realizarse en App Service mediante Web Deploy.

YAML

trigger:
- main

pool:
  vmImage: windows-latest

variables:
  buildConfiguration: 'Release'

steps:
- script: dotnet build --configuration $(buildConfiguration)
  displayName: 'dotnet build $(buildConfiguration)'
- 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'

Clásico

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, a continuación, seleccione Implementar Azure App Service. Esta es la tarea AzureRmWebAppDeployment.

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 a 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.

Nota:

Al implementar con Web Deploy, debe usar el tipo de conexión de Azure Resource Manager o AzureRM con las tareas AzureRmWebAppDeployment@3 y AzureRmWebAppDeployment@4. Este usa perfiles de publicación para la implementación cuando la autenticación básica está habilitada para la aplicación, y la autenticación de Entra ID más segura cuando la autenticación básica está deshabilitada.

Preguntas más frecuentes

¿Cuál es la diferencia entre los valores AzureWebApp y AzureRmWebAppDeployment?

La tarea Azure Web App (AzureWebApp) es la manera más sencilla de implementar en una aplicación web de Azure. De forma predeterminada, la implementación se produce en la aplicación raíz de la aplicación web de Azure.

La tarea de implementación de Azure App Service (AzureRmWebAppDeployment) puede controlar escenarios más personalizados, como:

• Modificar las opciones de configuración dentro de paquetes web y archivos de parámetros XML.
• Implementar con Web Deploy, si se usa para el proceso de implementación de IIS.
• Implementar en una aplicación virtual.
• Implemente en otros tipos de aplicaciones, como aplicaciones de contenedor, aplicaciones de funciones, WebJobs o API y aplicaciones móviles.

Nota:

Las transformaciones de archivos y la sustitución de variables también son compatibles con la tarea Transformación de archivos independiente para su uso en Azure Pipelines. Puede usar la tarea Transformación de archivos para aplicar transformaciones de archivo y sustituciones de variables en cualquier archivo de configuración y parámetros.

Recibo el mensaje "Se proporcionó un paquete de App Service o una ruta de acceso de carpeta no válidas".

En las canalizaciones de YAML, en función de la canalización, puede haber un error de coincidencia entre dónde se guarda el paquete web compilado y dónde se busca la tarea de implementación. Por ejemplo, la tarea AzureWebApp recoge el paquete web para la implementación. La tarea AzureWebApp busca en $(System.DefaultWorkingDirectory)/**/*.zip. Si el paquete web se deposita en otro lugar, modifique el valor de package.

Recibo el mensaje "Publicar con opciones de Web Deploy solo se admite cuando se usa el agente de Windows".

Este error se produce en la tarea azureRmWebAppDeployment al configurar la tarea para implementar mediante Web Deploy, si el agente no ejecuta Windows. Compruebe que YAML muestra algo similar al código siguiente:

pool:
  vmImage: windows-latest

Web Deploy no funciona cuando deshabilito la autenticación básica

Para obtener información sobre cómo obtener la autenticación de Microsoft Entra ID para trabajar con la tarea de AzureRmWebAppDeployment, consulte no puedo realizar usar Web Deploy en mi instancia de Azure App Service mediante la autenticación de Microsoft Entra ID desde mi agente de Windows

Pasos siguientes

• Personalización de la canalización de Azure DevOps.