Implementación de una aplicación web de Azure

Creación de un proyecto de .NET

Si no tiene un proyecto de .NET con el que trabajar, cree uno nuevo y cargue el código en el repositorio de GitHub o Azure Repos. Empiece por instalar el SDK de .NET 6.0 más reciente.

Cree una nueva aplicación web de .NET 6.

dotnet new webapp -f net6.0

Desde la misma sesión de terminal, ejecute la aplicación localmente mediante el dotnet run comando desde el directorio del proyecto.

dotnet run

Cargar el código

Upload el código a la nueva aplicación web GitHub o Azure Repos:

• Cree un repositorio de Git en Azure Repos.
• Cree un nuevo GitHub repositorio.

Creación de la canalización

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

2. Vaya a Pipelinesy, a continuación, 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 instalación.

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

8. Cuando aparezca la nueva canalización, echa un vistazo a YAML para ver lo que hace. Cuando esté listo, seleccione Guardar y ejecute.

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

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

   

2. Seleccione Azure Resource Manager 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 , y appNamepackage . El YAML completo debe tener este aspecto.

   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.

Todavía no estamos aconsejando a los nuevos usuarios que usen canalizaciones YAML para implementar desde Azure DevOps Server 2019. Si es un usuario de canalización experimentado y ya tiene una canalización de YAML para compilar la aplicación .NET Core, es posible que los ejemplos siguientes le sean útiles.

Las canalizaciones yaml no están disponibles en TFS.

La manera más sencilla de implementar en una aplicación web de Azure es usar la tarea Aplicación web de Azure ().

Implementar un paquete Web Deploy (ASP.NET)

Para implementar un paquete .zip Web Deploy (por ejemplo, desde una aplicación web de ASP.NET) enuna 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 $(System.DefaultWorkingDirectory) la carpeta del agente.

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

Implementación de una aplicación .NET

Si va a compilar una aplicación de .NET Core,use el siguiente recortado 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.

Implementación de una aplicación de Node.js JavaScript

Si va a compilar una aplicación de Node.js JavaScript,publicará todo el contenido del directorio de trabajo en la aplicación web. Este fragmento de código también genera un Web.config durante la implementación si la aplicación no tiene uno e inicia el controlador iisnode en la aplicación web de Azure:

- task: AzureWebApp@1
  inputs:
    azureSubscription: '<Azure service connections>'
    appName: '<Name of web app>'
    package: '$(System.DefaultWorkingDirectory)'
    customWebConfig: '-Handler iisnode -NodeStartFile server.js -appType node'

• 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.
• customWebConfig:genere web.config parámetros para aplicaciones python, Node.js, Go y Java. Se generará web.config e implementará un archivo estándar en Azure App Service si la aplicación no tiene uno.

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

Las canalizaciones yaml no están disponibles en TFS.

La manera más sencilla de implementar en una aplicación web de Azure es usar la tarea Aplicación web de Azure.

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

Las canalizaciones yaml no están disponibles en TFS.

La manera más fácil de empezar a trabajar con esta tarea es iniciar sesión como usuario propietario de la organización Azure DevOps Services y la suscripción de Azure. En este caso, no tendrá que crear manualmente la conexión de servicio. De lo contrario, para obtener información sobre cómo crear una conexión de servicio de Azure, consulte Creación de una conexión de servicio de Azure.

Para obtener información sobre cómo crear una conexión de servicio de Azure, consulte Creación de una conexión de servicio de Azure.

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 VirtualApplication propiedad de la tarea AzureRmWebAppDeployment :

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

• VirtualApplication:el nombre de la aplicación virtual que se ha configurado en el Azure Portal. Consulte Configuración de App Service aplicación en el Azure Portal para obtener más detalles.

Las canalizaciones yaml no están disponibles en TFS.

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.

En el ejemplo siguiente se 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 para implementar en una aplicación web en Linux.
• appName: el nombre del servicio de aplicaciones existente.
• deployToSlotOrASE:booleano. Implemente en una ranura de implementación existente o Azure App Service Environment.
• resourceGroupName:nombre del grupo de recursos. Obligatorio si deployToSlotOrASE es true.
• slotName:nombre de la ranura, el valor predeterminado es . Obligatorio si deployToSlotOrASE es true.
• SourceSlot:ranura enviada a producción cuando es true.
• SwapWithProduction:booleano. Intercambie el tráfico de la ranura de origen con producción.

Las canalizaciones yaml no están disponibles en TFS.

Use la opción Implementar en ranura o App Service Environment en la tarea Aplicación web de Azure para especificar la ranura en la que se implementará.

Use la opción Deploy to Slot (Implementar en ranura) App Service Environment en la Azure App Service Deploy (Implementar) para especificar la ranura en la que se implementará.

Puede usar trabajos en el archivo YAML para configurar una canalización de implementaciones. Mediante el uso de 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:
      buildType: 'current'
      artifactName: 'drop'
      targetPath: '$(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'

Las canalizaciones yaml no están disponibles en TFS.

En el fragmento de código siguiente se 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

Las canalizaciones yaml no están disponibles en TFS.

Para ello 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 solo 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 obtener más información sobre las condiciones, vea Especificar condiciones.

Las canalizaciones yaml no están disponibles en TFS.