Implementación en 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. 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:
   - 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.

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.

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

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.

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.

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

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.

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

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.

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.

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.

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