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 :
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.
Si votre compte Azure dispose des autorisations nécessaires, vous pouvez sélectionner 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.
1. Générer les informations d’identification du déploiement
La méthode recommandée pour l’authentification auprès d’Azure App Service pour GitHub Actions consiste à utiliser OpenID Connect. Il s’agit d’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.
Vous pouvez également vous authentifier avec une identité managée affectée par l’utilisateur, un principal de service ou un profil de publication.
La procédure ci-dessous vous permet de créer une application Active Directory, un principal de service et des informations d’identification fédérées à l’aide d’instructions Azure CLI. 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.
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.
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
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, $webappName par le nom de votre application web, et $assigneeObjectId par le 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/$webappName --assignee-principal-type ServicePrincipal
Remplacez APPLICATION-OBJECT-ID par l’appId (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"
]
}
Un profil de publication est une information d’identification au niveau de l’application. Configurez votre profil de publication en tant que secret GitHub.
Accédez à votre service d’application dans le portail Azure.
Dans la page Vue d’ensemble, sélectionnez Obtenir le profil de publication.
Enregistrez le fichier téléchargé. Vous utiliserez le contenu du fichier pour créer un secret GitHub.
Remarque
Depuis octobre 2020, le paramètre d’application WEBSITE_WEBDEPLOY_USE_SCM des applications web Linux doit être défini sur trueavant de télécharger le profil de publication. Cette condition sera supprimée ultérieurement.
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.
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.
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.
Ouvrez votre dépôt GitHub et accédez à Paramètres > Sécurité > Secrets et variables > Actions > Nouveau secret de dépôt.
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
Enregistrez chaque secret en sélectionnant Ajouter un secret.
Dans GitHub, accédez à votre référentiel. Sélectionnez Paramètres > Sécurité > Secrets et variables > Actions > Nouveau secret de référentiel.
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 :
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 :
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 :
Authentifiez-vous auprès d’App Service à l’aide du secret GitHub que vous avez créé.
Créez l’application web.
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.
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.
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
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
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: Build and deploy WAR app to Azure Web App using OpenID Connect
env:
JAVA_VERSION: '11' # set this to the Java version to use
DISTRIBUTION: microsoft # set this to the Java distribution
AZURE_WEBAPP_NAME: sampleapp # set this to the name of your web app
on: [push]
permissions:
id-token: write
contents: read
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Java version
uses: actions/setup-java@v3.0.0
with:
java-version: ${{ env.JAVA_VERSION }}
distribution: ${{ env.DISTRIBUTION }}
cache: 'maven'
- name: Build with Maven
run: mvn clean install
- name: Login to Azure
uses: azure/login@v2
with:
client-id: ${{ secrets.AZURE_CLIENT_ID }}
tenant-id: ${{ secrets.AZURE_TENANT_ID }}
subscription-id: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
- name: Deploy to Azure Web App
id: deploy-to-webapp
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
package: '*.war'
Vous trouverez cet exemple complet utilisant plusieurs travaux pour la génération et le déploiement également ici.
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
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
L’entrée publish-profile doit faire référence au secret GitHub AZURE_WEBAPP_PUBLISH_PROFILE que vous avez créé précédemment.
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'
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/'
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.
Créez et déployez une application Tomcat 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: Build and deploy WAR app to Azure Web App using publish profile
env:
JAVA_VERSION: '11' # set this to the Java version to use
DISTRIBUTION: microsoft # set this to the Java distribution
AZURE_WEBAPP_NAME: sampleapp # set this to the name of your web app
on: [push]
permissions:
id-token: write
contents: read
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Java version
uses: actions/setup-java@v3.0.0
with:
java-version: ${{ env.JAVA_VERSION }}
distribution: ${{ env.DISTRIBUTION }}
cache: 'maven'
- name: Build with Maven
run: mvn clean install
- name: Deploy to Azure Web App
id: deploy-to-webapp
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}
package: '*.war'
Vous trouverez cet exemple complet utilisant plusieurs travaux pour la génération et le déploiement également ici.
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 }}
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 }}
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.
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
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
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
Créez et déployez une application Tomcat 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: Build and deploy WAR app to Azure Web App using Service Principal Connect
env:
JAVA_VERSION: '11' # set this to the Java version to use
DISTRIBUTION: microsoft # set this to the Java distribution
AZURE_WEBAPP_NAME: sampleapp # set this to the name of your web app
on: [push]
permissions:
contents: read
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Set up Java version
uses: actions/setup-java@v3.0.0
with:
java-version: ${{ env.JAVA_VERSION }}
distribution: ${{ env.DISTRIBUTION }}
cache: 'maven'
- name: Build with Maven
run: mvn clean install
- name: Login to Azure
uses: azure/login@v2
with:
creds: ${{ secrets.AZURE_CREDENTIALS }}
- name: Deploy to Azure Web App
id: deploy-to-webapp
uses: azure/webapps-deploy@v3
with:
app-name: ${{ env.AZURE_WEBAPP_NAME }}
package: '*.war'
Vous trouverez cet exemple complet utilisant plusieurs travaux pour la génération et le déploiement également ici.
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
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
Comment faire pour déployer un fichier WAR via le plug-in Maven ?
Si vous avez configuré votre projet Java Tomcat avec le plug-in Maven, vous pouvez également déployer sur Azure App Service via ce plug-in. Si vous utilisez l’action GitHub Azure CLI, elle utilise vos informations d’identification de connexion Azure.
Vous trouverez plus d’informations sur l’action GitHub pour l’interface CLI et sur la façon de l’utiliser et de la configurer dans Action GitHub Azure CLI.
Pour plus d’informations sur la commande az webapp deploy, sur son utilisation, et sur les détails des paramètres, consultez la documentation az webapp deploy.
Comment faire pour déployer un fichier de démarrage ?
Utilisez GitHub Action pour Azure CLI. Par exemple :
Grâce à l’action Azure Web Deploy, vous pouvez automatiser votre workflow pour déployer des conteneurs personnalisés sur App Service à l’aide de GitHub Actions. Vous trouverez des informations détaillées sur les étapes de déploiement à l’aide de GitHub Actions dans Déployer sur un conteneur.
Comment faire pour mettre à jour la configuration Tomcat après un déploiement ?
Si vous souhaitez mettre à jour l’un de vos paramètres d’applications web après le déploiement, vous pouvez utiliser l’action Paramètres App Service.
- uses: azure/appservice-settings@v1
with:
app-name: 'my-app'
slot-name: 'staging' # Optional and needed only if the settings have to be configured on the specific deployment slot
app-settings-json: '[{ "name": "CATALINA_OPTS", "value": "-Dfoo=bar" }]'
connection-strings-json: '${{ secrets.CONNECTION_STRINGS }}'
general-settings-json: '{"alwaysOn": "false", "webSocketsEnabled": "true"}' #'General configuration settings as Key Value pairs'
id: settings
Vous trouverez plus d’informations sur cette action et sur son utilisation et sa configuration dans le dépôt Paramètres App Service.
Étapes suivantes
Consultez les références sur Azure GitHub Actions et les workflow :
