Déployer sur App Service à l’aide de GitHub Actions

Prenez en main GitHub Actions pour automatiser votre workflow et le déployer sur Azure App Service à partir de GitHub.

Prérequis

• Compte Azure avec un abonnement actif. Créez un compte gratuitement.
• Un compte GitHub. Si vous n’en avez pas, inscrivez-vous gratuitement.

Configurer le déploiement de GitHub Actions lors de la création de l’application

Le déploiement de GitHub Actions est intégré à l’Assistant Création d’application par défaut. Vous devez simplement définir Déploiement continu sur Activer sous l’onglet Déploiement et configurer l’organisation, le référentiel et la branche souhaités.

Lorsque vous activez le déploiement continu, l’Assistant Création d’application sélectionne automatiquement la méthode d’authentification en fonction de la sélection d’authentification de base et configure votre application et votre référentiel GitHub en conséquence :

Sélection de l’authentification de base	Méthode d'authentification
Désactiver	Identité affectée par l’utilisateur (OpenID Connect)
Activer	Authentification de base

Remarque

Si vous recevez une erreur lors de la création de votre application indiquant que votre compte Azure ne possède pas certaines autorisations, il se peut qu’il ne dispose pas des autorisations requises pour créer et configurer l’identité affectée par l’utilisateur. Pour obtenir une alternative, consultez Configurer le déploiement de GitHub Actions à partir du Centre de déploiement.

Configurer le déploiement de GitHub Actions à partir du Centre de déploiement

Pour une application existante, vous pouvez commencer rapidement avec GitHub Actions à l’aide du Centre de déploiement App Service. Cette méthode clé en main génère automatiquement un fichier de workflow GitHub Actions basé sur votre pile d’applications et le valide dans votre référentiel GitHub.

Le Centre de déploiement vous permet également de configurer facilement l’authentification OpenID Connect plus sécurisée avec l’option d’identité affectée par l’utilisateur.

Si votre compte Azure dispose des autorisations nécessaires, vous pouvez choisir de créer une identité affectée par l’utilisateur. Sinon, vous pouvez sélectionner une identité managée affectée par l’utilisateur existante dans la liste déroulante Identité. Vous pouvez collaborer avec votre administrateur Azure pour créer une identité managée affectée par l’utilisateur avec le rôle Contributeur de site web.

Pour plus d’informations, consultez Déploiement continu sur Azure App Service.

Configurer manuellement un workflow GitHub Actions

Vous pouvez également déployer un workflow sans utiliser le centre de déploiement.

1. Générer les informations d’identification du déploiement
2. Configurer le secret GitHub
3. Ajouter le fichier de workflow à votre référentiel GitHub

1. Générer les informations d’identification du déploiement

La méthode recommandée pour s’authentifier auprès d’Azure App Services pour GitHub Actions se fait avec une identité managée définie par l’utilisateur, et le moyen le plus simple pour cela consiste plutôt à configurer le déploiement GitHub Actions directement dans le portail et à sélectionner l’identité managée affectée par l’utilisateur.

Remarque

L’authentification à l’aide d’une identité managée affectée par l’utilisateur est actuellement en préversion.

Vous pouvez également vous authentifier auprès d’un principal de service, d’OpenID Connect ou d’un profil de publication.

Profil de publication

Remarque

Le profil de publication nécessite l’activation de l’authentification de base.

Un profil de publication est une information d’identification au niveau de l’application. Configurez votre profil de publication en tant que secret GitHub.

1. Accédez à votre service d’application dans le portail Azure.

2. Dans la page Vue d’ensemble, sélectionnez Obtenir le profil de publication.

3. Enregistrez le fichier téléchargé. Vous utiliserez le contenu du fichier pour créer un secret GitHub.

Remarque

À compter d’octobre 2020, les applications web Linux ont besoin que le paramètre d’application WEBSITE_WEBDEPLOY_USE_SCM soit défini sur trueavant de télécharger le profil de publication. Cette condition sera supprimée ultérieurement.

Principal du service

Vous pouvez créer un principal de service à l’aide de la commande az ad sp create-for-rbac dans Azure CLI. Exécutez cette commande en utilisant Azure Cloud Shell dans le portail Azure ou en sélectionnant le bouton Essayer.

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

Dans l’exemple précédent, remplacez les espaces réservés par votre ID d’abonnement, le nom de votre groupe de ressources et le nom de votre application. La sortie correspond à un objet JSON avec les informations d’identification de l’attribution de rôle qui fournit l’accès à votre application App Service, similaire à l’extrait de code JSON suivant. Copiez cet objet JSON pour une version ultérieure.

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

Important

Il est toujours conseillé d’accorder un accès minimal. L’étendue dans l’exemple précédent est limitée à l’application App Service spécifique, et non à l’ensemble du groupe de ressources.

OpenID Connect

OpenID Connect est une méthode d’authentification qui utilise des jetons de courte durée. La configuration d’OpenID Connect avec GitHub Actions est plus complexe, mais offre une sécurité renforcée.

1. Si vous n’avez pas d’application existante, inscrivez une nouvelle application Active Directory et un principal de service pouvant accéder aux ressources. Créez l’application Active Directory.

   az ad app create --display-name myApp
   

   Cette commande affiche une sortie JSON avec un appId qui est votre client-id. Enregistrez la valeur à utiliser comme secret GitHub AZURE_CLIENT_ID ultérieurement.

   Vous allez utiliser la valeur objectId lors de la création d’informations d’identification fédérées avec l’API Graph, et la référencer en tant que APPLICATION-OBJECT-ID.

2. Créer un principal de service. Remplacez le $appID par l’appID de votre sortie JSON.

   Cette commande génère une sortie JSON avec un objectId différent, qui sera utilisée à l’étape suivante. Le nouveau objectId est le assignee-object-id.

   copiez le appOwnerTenantId à utiliser comme secret GitHub pour AZURE_TENANT_ID ultérieurement.

    az ad sp create --id $appId
   

3. Créez une attribution de rôle par abonnement et objet. Par défaut, l’attribution de rôle est liée à votre abonnement par défaut. Remplacez $subscriptionId par votre ID d’abonnement, $resourceGroupName par le nom de votre groupe de ressources et $assigneeObjectId par le assignee-object-id généré. Découvrez comment gérer les abonnements Azure avec Azure CLI.

   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. Exécutez la commande suivante pour créer des informations d’identification d’identité fédérée pour votre application Active Directory.

   • Remplacez APPLICATION-OBJECT-ID par l’objectid (généré lors de la création de l’application) pour votre application Active Directory.
   • Définissez une valeur pour CREDENTIAL-NAME que vous référencerez ultérieurement.
   • Définissez subject. Sa valeur est définie par GitHub en fonction de votre workflow :
     • Travaux dans votre environnement GitHub Actions : repo:< Organization/Repository >:environment:< Name >
     • Pour les tâches non liées à un environnement, incluez le chemin de référence (ref path) de la branche/étiquette en fonction du chemin de référence utilisé pour déclencher le workflow : repo:< Organization/Repository >:ref:< ref path>. Par exemple, repo:n-username/ node_express:ref:refs/heads/my-branch ou repo:n-username/ node_express:ref:refs/tags/my-tag.
     • Pour les workflows déclenchés par un événement de demande de tirage (pull request) : 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"
       ]
   }     
   

Pour savoir comment créer une application Active Directory, un principal de service et des informations d’identification fédérées dans le portail Azure, consultez Connecter GitHub et Azure.

2. Configurer le secret GitHub

Profil de publication

Dans GitHub, accédez à votre référentiel. Sélectionnez Paramètres > Sécurité > Secrets et variables > Actions > Nouveau secret de référentiel.

Pour utiliser les informations d’identification au niveau de l’application, collez le contenu du fichier de profil de publication téléchargé dans le champ de valeur du secret. Nommez le secret AZURE_WEBAPP_PUBLISH_PROFILE.

Quand vous configurez votre fichier de workflow GitHub ultérieurement, vous utilisez AZURE_WEBAPP_PUBLISH_PROFILE dans l’action Déployer l’application web Azure. Par exemple :

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

Principal du service

Dans GitHub, accédez à votre référentiel. Sélectionnez Paramètres > Sécurité > Secrets et variables > Actions > Nouveau secret de référentiel.

Pour utiliser les informations d’identification au niveau de l’utilisateur, collez l’intégralité de la sortie JSON à partir de la commande Azure CLI dans le champ de valeur du secret. Nommez le secret AZURE_CREDENTIALS.

Quand vous configurez le fichier de workflow GitHub ultérieurement, vous utilisez le secret pour l’entrée creds de l’action Azure/connexion. Par exemple :

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

OpenID Connect

Vous devez fournir l’ID de client, l’ID de locataire et l’ID d’abonnement de votre application à l’action Azure/connexion. Vous pouvez fournir ces valeurs directement dans le workflow ou les stocker dans des secrets GitHub et les référencer dans votre workflow. L’enregistrement des valeurs en tant que secrets GitHub est l’option la plus sécurisée.

1. Ouvrez votre dépôt GitHub et accédez à Paramètres > Sécurité > Secrets et variables > Actions > Nouveau secret de dépôt.

2. Créez des secrets pour AZURE_CLIENT_ID, AZURE_TENANT_ID et AZURE_SUBSCRIPTION_ID. Utilisez les valeurs de votre application Active Directory pour vos secrets GitHub :

   Secret GitHub	Application Active Directory
   AZURE_CLIENT_ID	ID d’application (client)
   AZURE_TENANT_ID	ID de l’annuaire (locataire)
   AZURE_SUBSCRIPTION_ID	Identifiant d’abonnement

3. Enregistrez chaque secret en sélectionnant Ajouter un secret.

3. Ajouter le fichier de workflow à votre référentiel GitHub

Un workflow est défini par un fichier YAML (.yml) situé dans le chemin /.github/workflows/ de votre référentiel GitHub. Cette définition contient les étapes et les paramètres qui composent le workflow.

Au minimum, le fichier de workflow inclut les étapes distinctes suivantes :

1. Authentifiez-vous auprès d’App Service à l’aide du secret GitHub que vous avez créé.
2. Créez l’application web.
3. Déployez l’application web.

Pour déployer votre code sur une application App Service, vous utilisez l’action azure/webapps-deploy@v3. L’action nécessite le nom de votre application web dans app-name et, selon votre pile de langage, le chemin d’accès d’un fichier *.zip, *.war ou *.jar, ou d’un dossier à déployer dans package. Pour obtenir la liste complète des entrées possibles pour l’action azure/webapps-deploy@v3, consultez la définition action.yml.

Les exemples suivants illustrent la partie du workflow qui génère l’application web, dans différents langages pris en charge.

Profil de publication

L’entrée publish-profile doit faire référence au secret GitHub AZURE_WEBAPP_PUBLISH_PROFILE que vous avez créé précédemment.

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

Générez et déployez une application ASP.NET MVC qui utilise NuGet et publish-profile pour l’authentification.

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

Créez et déployez une application Java Spring sur Azure à l’aide d’un profil de publication Azure. L’entrée publish-profile fait référence au secret AZURE_WEBAPP_PUBLISH_PROFILE que vous avez créé précédemment.

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

Pour déployer un war au lieu d’un jar, modifiez la valeur 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

Créez et déployez une application Node.js sur Azure à l’aide du profil de publication de l’application. L’entrée publish-profile fait référence au secret AZURE_WEBAPP_PUBLISH_PROFILE que vous avez créé précédemment.

# 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

Créez et déployez une application Python sur Azure à l’aide du profil de publication de l’application. Notez la manière dont l’entrée publish-profile fait référence au secret AZURE_WEBAPP_PUBLISH_PROFILE que vous avez créé précédemment.

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

Principal du service

Pour déployer avec le principal de service que vous avez configuré, utilisez l’action azure/login@v1 avec la clé creds et faites référence au secret AZURE_CREDENTIALS que vous avez créé précédemment.

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

Créez et déployez une application ASP.NET MVC sur Azure à l’aide d’un principal de service Azure. Notez la manière dont l’entrée creds fait référence au secret AZURE_CREDENTIALS que vous avez créé précédemment.

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

Créez et déployez une application Java Spring sur Azure à l’aide d’un principal de service Azure. Notez la manière dont l’entrée creds fait référence au secret AZURE_CREDENTIALS que vous avez créé précédemment.

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

Créez et déployez une application Node.js sur Azure à l’aide d’un principal de service Azure. Notez la manière dont l’entrée creds fait référence au secret AZURE_CREDENTIALS que vous avez créé précédemment.

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

Créez et déployez une application Python sur Azure à l’aide d’un principal de service Azure. Notez la manière dont l’entrée creds fait référence au secret AZURE_CREDENTIALS que vous avez créé précédemment.

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

Pour déployer avec OpenID Connect à l’aide de l’identité managée que vous avez configurée, utilisez l’action azure/login@v1 avec les clés client-id, tenant-id et subscription-id et faites référence aux secrets GitHub que vous avez créés précédemment.

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

Créez et déployez une application ASP.NET MVC sur Azure à l’aide d’un principal de service Azure. L’exemple utilise des secrets GitHub pour les valeurs client-id, tenant-id et subscription-id. Vous pouvez également passer ces valeurs directement dans l’action login.

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

Créez et déployez une application Java Spring sur Azure à l’aide d’un principal de service Azure. L’exemple utilise des secrets GitHub pour les valeurs client-id, tenant-id et subscription-id. Vous pouvez également passer ces valeurs directement dans l’action login.

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

Étapes suivantes

Consultez les références sur Azure GitHub Actions et les workflow :

• Action Azure/connexion
• Action Azure/webapps-deploy
• Action Docker/connexion
• Action Azure/k8s-deploy
• Flux de travail d’actions à déployer sur Azure
• Flux de travail de démarrage
• Events that trigger workflows