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 para implementar en Azure App Service en la canalización. En escenarios más complicados, como la necesidad de usar parámetros XML en la implementación, puede usar la tarea Implementación de Azure App Service.

Prerrequisitos

Cree la canalización

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.

  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. Siga los pasos del asistente y seleccione primero GitHub como ubicación del código fuente.

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

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

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

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

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

Adición de la tarea Aplicación web de Azure

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

    Captura de pantalla de la tarea Aplicación web de Azure.

  2. Seleccione Azure Resource Manager en Tipo de conexión y elija la suscripción de Azure. Asegúrese de autorizar la conexión.

  3. Seleccione Aplicación web en Linux y escriba su azureSubscription, appNamey package. El código YAML completo debe ser similar a este.

  4. Seleccione Aplicación web en Linux y escriba su azureSubscription, appNamey package. El código YAML completo debe ser similar a este.

    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: '<Azure service connection>'
        appType: 'webAppLinux'
        appName: '<Name of web app>'
        package: '$(System.DefaultWorkingDirectory)/**/*.zip'
    
    • azureSubscription: su suscripción a Azure.
    • 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.

Ahora está listo para leer el resto de este tema para conocer algunos de los cambios más comunes que realizan los usuarios para personalizar una implementación de Azure Web App.

Uso de la tarea Aplicación web de Azure

La tarea Implementación de las aplicaciones web de Azure 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 Implementación de Azure App Service permite modificar las opciones de configuración dentro de paquetes web y archivos de parámetros XML.

Creación de un paquete de Web Deploy

Para implementar un paquete .zip de Web Deploy (por ejemplo, desde una aplicación web de ASP.NET) en una aplicación web de Azure, agregue el siguiente fragmento de código al archivo azure-pipelines.yml:

- task: AzureWebApp@1
  inputs:
    azureSubscription: '<Azure service connection>'
    appName: '<Name of web app>'
    package: $(System.DefaultWorkingDirectory)/**/*.zip    
  • azureSubscription: su suscripción a Azure.
  • 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.

En el fragmento de código se da por supuesto que los pasos de compilación del archivo YAML generan el archivo ZIP en la carpeta $(System.DefaultWorkingDirectory) del agente.

Para obtener información sobre las conexiones de servicio de Azure, consulte la siguiente sección.

Implementación de una aplicación .NET

Si va a compilar una aplicación .NET Core, 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: '<Azure service connection>'
    appType: 'webAppLinux'
    appName: '<Name of web app>'
    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.

Uso de una conexión de servicio

Para implementar en Azure App Service, deberá usar una conexión de servicio de Azure Resource Manager. La conexión de servicio de Azure almacena las credenciales para conectarse de Azure Pipelines o Azure DevOps Server a Azure.

Más información acerca de las conexiones de servicio de Azure Resource Manager. Si la conexión de servicio no funciona según lo previsto, consulte Solución de problemas de conexiones de servicio.

Necesitará una conexión de servicio de Azure para la tarea AzureWebApp. La conexión de servicio de Azure almacena las credenciales para conectarse de Azure Pipelines a Azure. Vea Creación de una conexión de servicio de Azure.

Implementación en una aplicación virtual

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

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

Implementación en una ranura

Puede configurar la aplicación web de Azure para que tenga varias ranuras. Las ranuras permiten implementar la aplicación de forma segura y probarla antes de ponerla a disposición de los clientes.

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: '<Azure service connection>'
    appType: webAppLinux
    appName: '<name of web app>'
    deployToSlotOrASE: true
    resourceGroupName: '<name of resource group>'
    slotName: staging

- task: AzureAppServiceManage@0
  inputs:
    azureSubscription: '<Azure service connection>'
    appType: webAppLinux
    WebAppName: '<name of web app>'
    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. El valor predeterminado es production. Es necesario si el valor de deployToSlotOrASE es true.
  • 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.

Implementación en varias aplicaciones web

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: '<Azure service connection>'
      appType: <app type>
      appName: '<name of test stage web app>'
      deployToSlotOrASE: true
      resourceGroupName: <resource 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: '<Azure service connection>'
      appType: <app type>
      appName: '<name of test stage web app>'
      resourceGroupName: <resource group name>
      package: '$(Pipeline.Workspace)/**/*.zip'

Realización de cambios de configuración

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.

La configuración de la aplicación también se puede resolver desde Key Vault mediante las referencias de Key Vault.

Para los desarrolladores de ASP.NET y ASP.NET Core, establecer la configuración de la aplicación en App Service es como establecerlos en <appSettings> en Web.config. Podría interesarle aplicar una configuración específica para el destino de la aplicación web antes de implementarla. Esto resulta útil al implementar la misma compilación en varias aplicaciones web de una canalización. Por ejemplo, si 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.

La tarea Implementación de Azure App Service permite a los usuarios modificar las opciones de configuración en los archivos de configuración (archivos *.config) dentro de paquetes web y archivos de parámetros XML (parameters.xml), en función del nombre de fase especificado.

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.

Sustitución de variables

El siguiente fragmento de código muestra un ejemplo de sustitución de variables:

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

Implementación condicional

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: '<Azure service connection>'
    appName: '<name of web app>'

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

(Clásico) Implementación de una canalización de versión

Puede usar una canalización de versión para buscar los artefactos publicados por la compilación y, a continuación, implementarlos en el sitio web de Azure.

  1. Realice una de las siguientes acciones para empezar a crear una canalización de versión:

    • Si acaba de completar una compilación de CI, elija el vínculo (por ejemplo, Compilación 20170815.1) para abrir el resumen de compilación. A continuación, elija Versión para iniciar una nueva canalización de versión que esté vinculada automáticamente a la canalización de compilación.

    • Abra la pestaña Versiones de Azure Pipelines, abra la lista desplegable de canalizaciones de versión (+) y elija Crear canalización de versión.

  2. La manera más fácil de crear una canalización de versión es usar una plantilla. Si va a implementar una aplicación Node.js, seleccione la plantilla Implementar aplicación Node.js en Azure App Service. Si no, seleccione la plantilla de Implementación de Azure App Service. Luego elija Aplicar.

    Nota:

    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. Si ha creado la nueva canalización de versión a partir de un resumen de compilación, compruebe que la canalización de compilación y el artefacto se muestran en la sección Artefactos de la pestaña Canalización. Si ha creado una nueva canalización de versión en la pestaña Versiones, elija el vínculo + Agregar y seleccione el artefacto de compilación.

  4. Elija el icono Implementación continua de la sección Artefactos, compruebe que el desencadenador de implementación continua está habilitado y agregue un filtro para incluir la rama main (principal).

    Nota:

    La implementación continua no está habilitada de forma predeterminada al crear una nueva canalización de versión desde la pestaña Versiones.

  5. Abra la pestaña Tareas y, con la Fase 1 seleccionada, configure las variables de propiedad de tarea de la siguiente manera:

    • Suscripción de Azure: seleccione una conexión en la lista Conexiones a servicios de Azure disponibles o cree una conexión con permisos más restrictivos a la suscripción de Azure. Si usa Azure Pipelines y ve un botón de Autorizar junto a la entrada, haga clic en él para autorizar a Azure Pipelines a conectarse a su suscripción de Azure. Si usa TFS o si no ve la suscripción de Azure deseada en la lista de suscripciones, consulte Conexión de servicio de Azure Resource Manager para configurar manualmente la conexión.

    • Nombre de App Service: seleccione el nombre de la aplicación web de la suscripción.

    Nota:

    Algunos valores de configuración de las tareas se pueden haber definido automáticamente como variables de fase cuando se creó una canalización de versión desde una plantilla. Estos valores de configuración no se pueden modificar en la configuración de tareas; para ello, debe seleccionar el elemento de fase principal.

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

Creación de una versión para implementar la aplicación

Ya está listo para crear una versión, es decir, para ejecutar la canalización de versión con los artefactos generados por una compilación específica. Esto dará lugar a la implementación de la compilación:

  1. Elija + Versión y seleccione Crear versión.

  2. En el panel Crear una nueva versión, compruebe que la versión del artefacto que desea usar está seleccionada y elija Crear.

  3. Seleccione el enlace de versión en el mensaje de la barra de información. Por ejemplo: "Versión Release-1 se ha creado".

  4. En la vista de canalización, elija el vínculo de estado en las fases de la canalización para ver los registros y la salida del agente.

  5. Una vez completada la versión, vaya al sitio que se ejecuta en Azure mediante la dirección URL de aplicación web http://{web_app_name}.azurewebsites.net y compruebe su contenido.

Pasos siguientes