Implementación de App Service con Acciones de GitHub

Comience a usar Acciones de GitHub para automatizar el flujo de trabajo e implementarlo en Azure App Service desde GitHub.

Requisitos previos

• Una cuenta de Azure con una suscripción activa. Cree una cuenta gratuita.
• Una cuenta de GitHub. Si no tiene ninguna, regístrese para obtener una gratuita.

Configuración de la implementación de Acciones de GitHub al crear la aplicación

La implementación de Acciones de GitHub se integra en el asistente de creación de aplicaciones predeterminado. Solo tiene que establecer Implementación continua en Habilitar en la pestaña Implementación y configurar la organización, el repositorio y la rama que desee.

Al habilitar la implementación continua, el asistente de creación de aplicaciones selecciona automáticamente el método de autenticación en función de la selección de autenticación básica y configura la aplicación y el repositorio de GitHub en consecuencia:

Selección de autenticación básica	Método de autenticación
Deshabilitar	Identidad asignada por el usuario (OpenID Connect)
Habilitar	Autenticación básica

Nota:

Si recibe un error al crear la aplicación diciendo que la cuenta de Azure no tiene determinados permisos, es posible que no tenga los permisos necesarios para crear y configurar la identidad asignada por el usuario. Para obtener una alternativa, consulte Configuración de la implementación de Acciones de GitHub desde el centro de implementación.

Configuración de la implementación de Acciones de GitHub desde el centro de implementación

Para una aplicación existente, puede empezar a trabajar rápidamente con Acciones de GitHub con el centro de implementación de App Service. Este método llave en mano genera automáticamente un archivo de flujo de trabajo de Acciones de GitHub basado en la pila de aplicaciones y lo confirma en el repositorio de GitHub.

El centro de implementación también le permite configurar fácilmente la autenticación de OpenID Connect más segura con la opción identidad asignada por el usuario.

Si la cuenta de Azure tiene los permisos necesarios, puede seleccionar crear una identidad asignada por el usuario. De lo contrario, puede seleccionar una identidad administrada asignada por el usuario existente en la lista desplegable Identidad. Puede trabajar con el administrador de Azure para crear una identidad administrada asignada por el usuario con el rol Colaborador del sitio web.

Para más información, consulte Implementación continua en Azure App Service.

Configuración manual de un flujo de trabajo de Acciones de GitHub

También puede implementar un flujo de trabajo sin usar el centro de implementación.

1. Genere las credenciales de implementación
2. Configuración del secreto de GitHub
3. Adición del archivo de flujo de trabajo al repositorio de GitHub

1. Genere las credenciales de implementación.

La manera recomendada de autenticarse con instancias de Azure App Service para Acciones de GitHub es con una identidad administrada definida por el usuario y la forma más sencilla de hacerlo es configurando la implementación de Acciones de GitHub directamente en el portal en su lugar y seleccionando identidad administrada asignada por el usuario.

Nota:

La autenticación mediante una identidad administrada asignada por el usuario está actualmente en versión preliminar.

Como alternativa, puede autenticarse con una entidad de servicio, OpenID Connect o un perfil de publicación.

Perfil de publicación

Nota:

El perfil de publicación requiere que se habilite la autenticación básica.

Un perfil de publicación es una credencial de nivel de aplicación. Configure el perfil de publicación como secreto de GitHub.

1. En Azure Portal, vaya a la aplicación de App Service.

2. En la página de Información general, seleccione Obtener perfil de publicación.

3. Guarde el archivo descargado. Usará el contenido del archivo para crear un secreto de GitHub.

Nota:

Desde octubre de 2020, las aplicaciones web de Linux necesitan que la configuración de la aplicación WEBSITE_WEBDEPLOY_USE_SCM esté establecida en trueantes de descargar el perfil de publicación. Este paso dejará de ser un requisito en el futuro.

Entidad de servicio

Puede crear una entidad de servicio mediante el comando az ad sp create-for-rbac de la CLI de Azure. Puede ejecutar este comando mediante Azure Cloud Shell en Azure Portal o haciendo clic en el botón Probar.

az ad sp create-for-rbac --name "myApp" --role contributor \
                            --scopes /subscriptions/<subscription-id>/resourceGroups/<group-name>/providers/Microsoft.Web/sites/<app-name> \
                            --json-auth

En el ejemplo anterior, se reemplazan los marcadores de posición por su identificador de suscripción, el nombre del grupo de recursos y el nombre de la aplicación. La salida es un objeto JSON con las credenciales de asignación de roles que proporcionan acceso a la aplicación App Service similar al siguiente fragmento de código JSON. Copie este objeto JSON para más adelante.

  {
    "clientId": "<GUID>",
    "clientSecret": "<GUID>",
    "subscriptionId": "<GUID>",
    "tenantId": "<GUID>",
    (...)
  }

Importante

Siempre es recomendable conceder acceso mínimo. El ámbito del ejemplo anterior se limita a la aplicación específica de App Service y no a todo el grupo de recursos.

OpenID Connect

Open ID Connect es un método de autenticación que usa tokens de corta duración. La configuración de OpenID Connect con Acciones de GitHub es más compleja, pero ofrece seguridad reforzada.

1. Si no tiene una aplicación existente, registre una nueva aplicación de Active Directory y una entidad de servicio que puedan acceder a los recursos. Cree la aplicación de Active Directory.

   az ad app create --display-name myApp
   

   Este comando genera un JSON con un appId que es su client-id. Guarde el valor que se usará como secreto de GitHub de AZURE_CLIENT_ID más adelante.

   Usará el valor de objectId al crear credenciales federadas con Graph API y hará referencia a dicho valor como APPLICATION-OBJECT-ID.

2. Crear una entidad de servicio. Reemplace $appID por el valor de appId de la salida de JSON.

   Este comando genera una salida de JSON con un objectId diferente y se usará en el siguiente paso. El nuevo objectId es assignee-object-id.

   Copie el appOwnerTenantId para usarlo como secreto de GitHub para AZURE_TENANT_ID más adelante.

    az ad sp create --id $appId
   

3. Cree una asignación de roles por suscripción y objeto. De forma predeterminada, la asignación de roles se vincula a la suscripción predeterminada. Reemplace $subscriptionId por el identificador de suscripción, $resourceGroupName por el nombre del grupo de recursos y $assigneeObjectId por el valor de assignee-object-id generado. Obtenga información sobre cómo administrar suscripciones de Azure con la CLI de Azure.

   az role assignment create --role contributor --subscription $subscriptionId --assignee-object-id  $assigneeObjectId --scope /subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Web/sites/ --assignee-principal-type ServicePrincipal
   

4. Ejecute el siguiente comando para crear una credencial de identidad federada para la aplicación de Active Directory.

   • Reemplace APPLICATION-OBJECT-ID por el objectId (generado al crear la aplicación) de la aplicación de Active Directory.
   • Establezca un valor para CREDENTIAL-NAME al que haga referencia más adelante.
   • Establezca subject. Su valor lo define GitHub en función del flujo de trabajo:
     • Trabajos en el entorno de Acciones de GitHub: repo:< Organization/Repository >:environment:< Name >
     • En el caso de los trabajos no vinculados a un entorno, incluya la ruta de acceso de referencia para una rama o etiqueta en función de la ruta de acceso de referencia usada para desencadenar el flujo de trabajo: repo:< Organization/Repository >:ref:< ref path>. Por ejemplo, repo:n-username/ node_express:ref:refs/heads/my-branch o repo:n-username/ node_express:ref:refs/tags/my-tag.
     • En el caso de los flujos de trabajo desencadenados por un evento de solicitud de incorporación de cambios: repo:< Organization/Repository >:pull_request.

   az ad app federated-credential create --id <APPLICATION-OBJECT-ID> --parameters credential.json
   ("credential.json" contains the following content)
   {
       "name": "<CREDENTIAL-NAME>",
       "issuer": "https://token.actions.githubusercontent.com",
       "subject": "repo:organization/repository:ref:refs/heads/main",
       "description": "Testing",
       "audiences": [
           "api://AzureADTokenExchange"
       ]
   }     
   

Para obtener información sobre cómo crear una aplicación, una entidad de servicio y credenciales federadas de Active Directory en Azure Portal, consulte Conexión de GitHub y Azure.

2. Configuración del secreto de GitHub

Perfil de publicación

En GitHub, examine el repositorio. Seleccione Configuración > Seguridad > Secretos y variables > Acciones > Nuevo secreto del repositorio.

Para usar las credenciales de nivel de aplicación, pegue el contenido del archivo del perfil de publicación descargado en el campo de valor del secreto. Asigne al secreto el siguiente nombre: AZURE_WEBAPP_PUBLISH_PROFILE.

Al configurar el archivo de flujo de trabajo de GitHub más adelante, usará la AZURE_WEBAPP_PUBLISH_PROFILE en la acción Implementar aplicación web de Azure. Por ejemplo:

- uses: azure/webapps-deploy@v2
  with:
    publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}

Entidad de servicio

En GitHub, examine el repositorio. Seleccione Configuración > Seguridad > Secretos y variables > Acciones > Nuevo secreto del repositorio.

Para utilizar las credenciales de nivel de usuario, pegue toda la salida JSON del comando CLI de Azure en el campo de valor del secreto. Asigne al secreto el siguiente nombre: AZURE_CREDENTIALS.

Cuando configure el archivo de flujo de trabajo de GitHub más adelante, usará el secreto para la entrada creds de Azure/login. Por ejemplo:

- uses: azure/login@v1
  with:
    creds: ${{ secrets.AZURE_CREDENTIALS }}

OpenID Connect

Debe especificar el identificador de cliente, el identificador de inquilino y el identificador de suscripción en la acción de Azure/login. Estos valores se pueden proporcionar directamente en el flujo de trabajo o se pueden almacenar en secretos de GitHub y se puede hacer referencia a ellos en el flujo de trabajo. Guardar los valores como secretos de GitHub es la opción más segura.

1. Abra el repositorio de GitHub y vaya a Configuración > Seguridad > Secretos y variables > Acciones > Nuevo secreto de repositorio.

2. Cree secretos para AZURE_CLIENT_ID, AZURE_TENANT_ID y AZURE_SUBSCRIPTION_ID. Use estos valores de la aplicación de Active Directory para los secretos de GitHub:

   Secreto de GitHub	Aplicación de Active Directory
   AZURE_CLIENT_ID	Id. de aplicación (cliente)
   AZURE_TENANT_ID	Id. de directorio (inquilino)
   AZURE_SUBSCRIPTION_ID	Id. de suscripción

3. Guarde todos los secretos, para lo que debe seleccionar Add secret (Agregar secreto).

3. Adición del archivo de flujo de trabajo al repositorio de GitHub

Un archivo YAML (.yml) define un flujo de trabajo en la ruta de acceso /.github/workflows/ de su repositorio de GitHub. En esta definición se incluyen los diversos pasos y parámetros que componen el flujo de trabajo.

Como mínimo, el archivo de flujo de trabajo tendría los siguientes pasos diferenciados:

1. Autentíquese con App Service mediante el secreto de GitHub que creó.
2. Cree la aplicación web.
3. Implemente la aplicación web.

Para implementar el código en una aplicación de App Service, use la acción azure/webapps-deploy@v3. La acción requiere el nombre de la aplicación web en app-name y, en función de la pila de lenguaje, la ruta de acceso de un *.zip, *.war, *.jar o carpeta para implementar en package. Para obtener una lista completa de las posibles entradas para la acción azure/webapps-deploy@v3, consulte la definición de action.yml.

En los siguientes ejemplos se muestra la parte del flujo de trabajo que compila la aplicación web en los diversos lenguajes admitidos.

Perfil de publicación

La entrada publish-profile debe hacer referencia al secreto de GitHub AZURE_WEBAPP_PUBLISH_PROFILE que creó anteriormente.

ASP.NET Core

name: .NET Core CI

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app-name    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'           # set this to the dot net version to use

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Checkout the repo
      - uses: actions/checkout@main
      
      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }} 
      
      # Run dotnet build and publish
      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration Release
          dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp' 
          
      # Deploy to Azure Web apps
      - name: 'Run Azure webapp deploy action using publish profile credentials'
        uses: azure/webapps-deploy@v3
        with: 
          app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
          publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE  }} # Define secret variable in repository settings as per action documentation
          package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'

ASP.NET

Compile e implemente una aplicación ASP.NET MVC que use NuGet y publish-profile para la autenticación.

name: Deploy ASP.NET MVC App deploy to Azure Web App

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  NUGET_VERSION: '5.3.x'           # set this to the dot net version to use

jobs:
  build-and-deploy:
    runs-on: windows-latest
    steps:

    - uses: actions/checkout@main  
    
    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: ${{ env.NUGET_VERSION}}
    - name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
      run: nuget restore
  
    - name: Add msbuild to PATH
      uses: microsoft/setup-msbuild@v1.0.2

    - name: Run MSBuild
      run: msbuild .\SampleWebApplication.sln
       
    - name: 'Run Azure webapp deploy action using publish profile credentials'
      uses: azure/webapps-deploy@v3
      with: 
        app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE  }} # Define secret variable in repository settings as per action documentation
        package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'

Java

Compile e implemente una aplicación Java Spring en Azure con un perfil de publicación de Azure. La entrada publish-profile hace referencia al secreto de AZURE_WEBAPP_PUBLISH_PROFILE que creó anteriormente.

name: Java CI with Maven

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - name: Set up JDK 1.8
      uses: actions/setup-java@v3
      with:
        java-version: 1.8
    - name: Build with Maven
      run: mvn -B package --file pom.xml
      working-directory: my-app-path
    - name: Azure WebApp
      uses: Azure/webapps-deploy@v3
      with:
        app-name: my-app-name
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: my/target/*.jar

Para implementar un archivo war en lugar de jar, cambie el valor de package.

    - name: Azure WebApp
      uses: Azure/webapps-deploy@v3
      with:
        app-name: my-app-name
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: my/target/*.war

Node.js

Compile e implemente una aplicación Node.js en Azure con el perfil de publicación de la aplicación. La entrada publish-profile hace referencia al secreto de AZURE_WEBAPP_PUBLISH_PROFILE que creó anteriormente.

# File: .github/workflows/workflow.yml
name: JavaScript CI

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app-name   # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path'      # set this to the path to your web app project, defaults to the repository root
  NODE_VERSION: '18.x'                # set this to the node version to use

jobs:
  build-and-deploy:
    name: Build and Deploy
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@main
    - name: Use Node.js ${{ env.NODE_VERSION }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
    - name: npm install, build, and test
      run: |
        # Build and test the project, then
        # deploy to Azure Web App.
        npm install
        npm run build --if-present
        npm run test --if-present
      working-directory: my-app-path
    - name: 'Deploy to Azure WebApp'
      uses: azure/webapps-deploy@v3
      with: 
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

Python

Compile e implemente una aplicación Python en Azure con el perfil de publicación de la aplicación. Observe cómo la entrada publish-profile hace referencia al secreto de AZURE_WEBAPP_PUBLISH_PROFILE que creó anteriormente.

name: Python CI

on:
  [push]

env:
  AZURE_WEBAPP_NAME: my-web-app # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    - name: Set up Python 3.x
      uses: actions/setup-python@v4
      with:
        python-version: 3.x
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Building web app
      uses: azure/appservice-build@v2
    - name: Deploy web App using GH Action azure/webapps-deploy
      uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

Entidad de servicio

Para implementar con la entidad de servicio que configuró, use la acción azure/login@v1 con la clave creds y haga referencia al secreto de AZURE_CREDENTIALS que creó anteriormente.

ASP.NET Core

name: .NET Core

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'           # set this to the dot net version to use

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Checkout the repo
      - uses: actions/checkout@main
      - uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      
      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }} 
      
      # Run dotnet build and publish
      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration Release
          dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp' 
          
      # Deploy to Azure Web apps
      - name: 'Run Azure webapp deploy action using Azure Credentials'
        uses: azure/webapps-deploy@v3
        with: 
          app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
          package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
      
      - name: logout
        run: |
          az logout

ASP.NET

Compile e implemente una aplicación ASP.NET MVC en Azure con una entidad de servicio de Azure. Observe cómo la entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó anteriormente.

name: Deploy ASP.NET MVC App deploy to Azure Web App

on: [push]

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  NUGET_VERSION: '5.3.x'           # set this to the dot net version to use

jobs:
  build-and-deploy:
    runs-on: windows-latest
    steps:

    # checkout the repo
    - uses: actions/checkout@main
    
    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: ${{ env.NUGET_VERSION}}
    - name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
      run: nuget restore
  
    - name: Add msbuild to PATH
      uses: microsoft/setup-msbuild@v1.0.2

    - name: Run MSBuild
      run: msbuild .\SampleWebApplication.sln
       
    - name: 'Run Azure webapp deploy action using Azure Credentials'
      uses: azure/webapps-deploy@v3
      with: 
        app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
        package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'
  
    # Azure logout 
    - name: logout
      run: |
        az logout

Java

Compile e implemente una aplicación Java Spring en Azure con una entidad de servicio de Azure. Observe cómo la entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó anteriormente.

name: Java CI with Maven

on: [push]

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}
    - name: Set up JDK 1.8
      uses: actions/setup-java@v3
      with:
        java-version: 1.8
    - name: Build with Maven
      run: mvn -B package --file pom.xml
      working-directory: complete
    - name: Azure WebApp
      uses: Azure/webapps-deploy@v3
      with:
        app-name: my-app-name
        package: my/target/*.jar

    # Azure logout 
    - name: logout
      run: |
        az logout

Node.js

Compile e implemente una aplicación Node.js en Azure con una entidad de servicio de Azure. Observe cómo la entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó anteriormente.

name: JavaScript CI

on: [push]

name: Node.js

env:
  AZURE_WEBAPP_NAME: my-app   # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path'      # set this to the path to your web app project, defaults to the repository root
  NODE_VERSION: '18.x'                # set this to the node version to use

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    # checkout the repo
    - name: 'Checkout GitHub Action' 
      uses: actions/checkout@main
   
    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}
        
    - name: Setup Node ${{ env.NODE_VERSION }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
    
    - name: 'npm install, build, and test'
      run: |
        npm install
        npm run build --if-present
        npm run test --if-present
      working-directory:  my-app-path
               
    # deploy web app using Azure credentials
    - uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

    # Azure logout 
    - name: logout
      run: |
        az logout

Python

Compile e implemente una aplicación Python en Azure con una entidad de servicio de Azure. Observe cómo la entrada creds hace referencia al secreto de AZURE_CREDENTIALS que creó anteriormente.

name: Python application

on:
  [push]

env:
  AZURE_WEBAPP_NAME: my-app # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - uses: azure/login@v1
      with:
        creds: ${{ secrets.AZURE_CREDENTIALS }}

    - name: Set up Python 3.x
      uses: actions/setup-python@v4
      with:
        python-version: 3.x
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Deploy web App using GH Action azure/webapps-deploy
      uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
    - name: logout
      run: |
        az logout

OpenID Connect

Para implementar con OpenID Connect mediante la identidad administrada que configuró, use la acción azure/login@v1 con las claves de client-id, tenant-id y subscription-id, y haga referencia a los secretos de GitHub que creó anteriormente.

ASP.NET Core

name: .NET Core

on: [push]

permissions:
      id-token: write
      contents: read

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  DOTNET_VERSION: '6.0.x'           # set this to the dot net version to use

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      # Checkout the repo
      - uses: actions/checkout@main
      - uses: azure/login@v1
        with:
          client-id: ${{ secrets.AZURE_CLIENT_ID }}
          tenant-id: ${{ secrets.AZURE_TENANT_ID }}
          subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

      
      # Setup .NET Core SDK
      - name: Setup .NET Core
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: ${{ env.DOTNET_VERSION }} 
      
      # Run dotnet build and publish
      - name: dotnet build and publish
        run: |
          dotnet restore
          dotnet build --configuration Release
          dotnet publish -c Release --property:PublishDir='${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp' 
          
      # Deploy to Azure Web apps
      - name: 'Run Azure webapp deploy action using publish profile credentials'
        uses: azure/webapps-deploy@v3
        with: 
          app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
          package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/myapp'
      
      - name: logout
        run: |
          az logout

ASP.NET

Compile e implemente una aplicación ASP.NET MVC en Azure con una entidad de servicio de Azure. En el ejemplo se usan secretos de GitHub para los valores client-id, tenant-id y subscription-id. Estos valores también se pueden pasar directamente en la acción de inicio de sesión.

name: Deploy ASP.NET MVC App deploy to Azure Web App

on: [push]

permissions:
      id-token: write
      contents: read

env:
  AZURE_WEBAPP_NAME: my-app    # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.'      # set this to the path to your web app project, defaults to the repository root
  NUGET_VERSION: '5.3.x'           # set this to the dot net version to use

jobs:
  build-and-deploy:
    runs-on: windows-latest
    steps:

    # checkout the repo
    - uses: actions/checkout@main
    
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    - name: Install Nuget
      uses: nuget/setup-nuget@v1
      with:
        nuget-version: ${{ env.NUGET_VERSION}}
    - name: NuGet to restore dependencies as well as project-specific tools that are specified in the project file
      run: nuget restore
  
    - name: Add msbuild to PATH
      uses: microsoft/setup-msbuild@v1.0.2

    - name: Run MSBuild
      run: msbuild .\SampleWebApplication.sln
       
    - name: 'Run Azure webapp deploy action using publish profile credentials'
      uses: azure/webapps-deploy@v3
      with: 
        app-name: ${{ env.AZURE_WEBAPP_NAME }} # Replace with your app name
        package: '${{ env.AZURE_WEBAPP_PACKAGE_PATH }}/SampleWebApplication/'
  
    # Azure logout 
    - name: logout
      run: |
        az logout

Java

Compile e implemente una aplicación Java Spring en Azure con una entidad de servicio de Azure. En el ejemplo se usan secretos de GitHub para los valores client-id, tenant-id y subscription-id. Estos valores también se pueden pasar directamente en la acción de inicio de sesión.

name: Java CI with Maven

on: [push]

permissions:
      id-token: write
      contents: read

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
    - name: Set up JDK 1.8
      uses: actions/setup-java@v3
      with:
        java-version: 1.8
    - name: Build with Maven
      run: mvn -B package --file pom.xml
      working-directory: complete
    - name: Azure WebApp
      uses: Azure/webapps-deploy@v3
      with:
        app-name: my-app-name
        package: my/target/*.jar

    # Azure logout 
    - name: logout
      run: |
        az logout

Node.js

name: JavaScript CI

on: [push]

permissions:
      id-token: write
      contents: read

name: Node.js

env:
  AZURE_WEBAPP_NAME: my-app   # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: 'my-app-path'      # set this to the path to your web app project, defaults to the repository root
  NODE_VERSION: '18.x'                # set this to the node version to use

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    # checkout the repo
    - name: 'Checkout GitHub Action' 
      uses: actions/checkout@main
   
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
        
    - name: Setup Node ${{ env.NODE_VERSION }}
      uses: actions/setup-node@v4
      with:
        node-version: ${{ env.NODE_VERSION }}
    
    - name: 'npm install, build, and test'
      run: |
        npm install
        npm run build --if-present
        npm run test --if-present
      working-directory:  my-app-path
               
    # deploy web app using Azure credentials
    - uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}

    # Azure logout 
    - name: logout
      run: |
        az logout

Python

name: Python application

on:
  [push]

permissions:
      id-token: write
      contents: read

env:
  AZURE_WEBAPP_NAME: my-app # set this to your application's name
  AZURE_WEBAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - uses: azure/login@v1
      with:
        client-id: ${{ secrets.AZURE_CLIENT_ID }}
        tenant-id: ${{ secrets.AZURE_TENANT_ID }}
        subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}

    - name: Set up Python 3.x
      uses: actions/setup-python@v4
      with:
        python-version: 3.x
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Deploy web App using GH Action azure/webapps-deploy
      uses: azure/webapps-deploy@v3
      with:
        app-name: ${{ env.AZURE_WEBAPP_NAME }}
        package: ${{ env.AZURE_WEBAPP_PACKAGE_PATH }}
    - name: logout
      run: |
        az logout

Pasos siguientes

Consulte las referencias en flujos de trabajo y Acciones de GitHub de Azure:

• Acción Azure/login
• Azure/webapps-deploy action
• Acción Docker/login
• Acción Azure/k8s-deploy
• Flujos de trabajo de acciones para implementar en Azure
• Flujos de trabajo de inicio
• Eventos que desencadenan flujos de trabajo