Héberger une application Durable Functions avec le serveur principal MSSQL dans Azure Container Apps (.NET isolé)

Azure Container Apps est la seule option d’hébergement qui prend en charge la mise à l’échelle automatique pilotée par les événements (mise à l’échelle à zéro) pour Durable Functions lorsque vous utilisez le fournisseur de stockage SQL (MSSQL) Microsoft. Si vous utilisez un autre back-end de stockage, vous devez définir le nombre minimal de réplicas sur supérieur à zéro.

Conseil / Astuce

Pour les nouveaux projets, envisagez d’utiliser le planificateur de tâches Durable, qui est le serveur principal Azure géré recommandé pour les flux de travail durables. Ce guide traite spécifiquement du back-end MSSQL.

Pour en savoir plus sur l’exécution des fonctions Azure dans les Container Apps en général, consultez l’hébergement des fonctions Azure par Azure Container Apps.

Dans cet article, vous allez apprendre à :

Créez une image Docker à partir d’un projet Durable Functions local.
Créez une application conteneur Azure et des ressources associées.
Déployez l’image sur Azure Container App et configurez l’authentification.

Prerequisites

Visual Studio Code installé.
KIT SDK .NET 8.0.
Docker et ID Docker
Azure CLI version 2.47 ou ultérieure.
Azure Functions Core Tools
compte Azure avec un abonnement actif. Créez un compte gratuitement.
Outil de test HTTP qui sécurise vos données. Pour découvrir plus d’informations, consultez Outils de test HTTP.

Créer un projet Durable Functions local

Ce guide suppose que vous disposez d’un projet .NET isolé Durable Functions configuré avec le serveur principal MSSQL. Si vous n’en avez pas encore, suivez le guide de démarrage rapide MSSQL pour en créer et en tester un localement, puis revenez ici.

Avant de continuer, vérifiez que :

Votre projet cible .NET 8.0 avec le modèle de travailleur isolé
Le fournisseur de stockage MSSQL est configuré dans host.json
L’application s’exécute correctement avec func start

Créez un fichier Dockerfile à la racine du projet qui décrit l’environnement minimal requis pour exécuter l’application de fonction dans un conteneur.

Dans le répertoire racine du projet, créez un fichier nommé Dockerfile.

Copiez/collez le contenu suivant dans le fichier Dockerfile.

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS installer-env

COPY . /src/dotnet-function-app
RUN cd /src/dotnet-function-app && \
mkdir -p /home/site/wwwroot && \
dotnet publish *.csproj --output /home/site/wwwroot

# To enable ssh & remote debugging on app service change the base image to the one below
# FROM mcr.microsoft.com/azure-functions/dotnet-isolated:4-dotnet-isolated8.0-appservice
FROM mcr.microsoft.com/azure-functions/dotnet-isolated:4-dotnet-isolated8.0
ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
    AzureFunctionsJobHost__Logging__Console__IsEnabled=true

COPY --from=installer-env ["/home/site/wwwroot", "/home/site/wwwroot"]

Enregistrez le fichier.
Ajoutez un fichier .dockerignore avec le contenu suivant :
```
local.settings.json
```
Enregistrez le fichier .dockerignore .

Générer l’image de conteneur

Créez l’image Docker. Recherchez la liste complète des images de base prises en charge pour Azure Functions dans la base Azure Functions par Microsoft | Docker Hub

Démarrez le démon Docker.
Connectez-vous à Docker avec la docker login commande.
Lorsque vous y êtes invité, connectez-vous avec votre nom d’utilisateur et votre mot de passe. Un message « Connexion réussie » confirme que vous êtes connecté.
Accédez au répertoire racine de votre projet.
Exécutez la commande suivante pour générer l’image, en remplaçant <DOCKER_ID> par votre ID de compte Docker Hub :
```
dockerId=<DOCKER_ID>
imageName=<IMAGE_NAME>
imageVersion=v1.0.0

docker build --tag $dockerId/$imageName:$imageVersion .
```
Note

Si vous exécutez sur un Mac de série M, utilisez --platform linux/amd64 plutôt.
Envoyez l’image à Docker :
```
docker push $dockerId/$imageName:$imageVersion
```
Selon la vitesse du réseau, l’envoi d’images initiale peut prendre quelques minutes. Pendant que vous attendez, passez à la section suivante.

Créer des ressources Azure pour Durable Functions sur Container Apps

Créez les ressources Azure nécessaires pour exécuter Durable Functions sur une application conteneur.

Groupe de ressources Azure : Groupe de ressources contenant toutes les ressources créées.
Environnement Azure Container App : Environnement hébergeant l’application conteneur.
Application conteneur Azure : L’image contenant l’application Fonctions durables est déployée dans cette application.
Compte de stockage Azure : Requis par l’application de fonction pour stocker les données liées à l’application, telles que le code de l’application.

Configuration initiale

Dans un nouveau terminal, connectez-vous à votre abonnement Azure :
```
az login  

az account set -s <subscription_name>
```

Exécutez les commandes requises pour configurer l’extension CLI Azure Container Apps :

az upgrade

az extension add --name containerapp --upgrade

az provider register --namespace Microsoft.App

az provider register --namespace Microsoft.OperationalInsights

Un profil de charge de travail détermine la quantité de ressources de calcul et de mémoire disponibles pour les applications conteneur déployées dans un environnement. Créez un profil de charge de travail Consommation afin d’obtenir une prise en charge de la mise à l’échelle à zéro et un paiement à l’utilisation.

Définissez les variables d’environnement.

location=<REGION>
resourceGroup=<RESOURCE_GROUP_NAME>
storage=<STORAGE_NAME>
containerAppEnv=<CONTAINER_APP_ENVIRONMNET_NAME>
functionApp=<APP_NAME>
vnet=<VNET_NAME>

Créez un groupe de ressources.

az group create --name $resourceGroup --location $location

Créez l’environnement d’application conteneur.

az containerapp env create \
  --enable-workload-profiles \
  --resource-group $resourceGroup \
  --name $containerAppEnv \
  --location $location \

Créez une application conteneur basée sur l’image Durable Functions.

az containerapp create --resource-group $resourceGroup \
--name $functionApp \
--environment $containerAppEnv \
--image $dockerId/$imageName:$imageVersion \
--ingress external \
--kind functionapp \
--query properties.outputs.fqdn

Notez l’URL de l’application, qui doit ressembler à https://<APP_NAME>.<ENVIRONMENT_IDENTIFIER>.<REGION>.azurecontainerapps.io.

Créer des bases de données

Créez un compte de stockage Azure, requis par l’application de fonction.

az storage account create --name $storage --location $location --resource-group $resourceGroup --sku Standard_LRS

Dans le portail Azure, créez une base de données Azure SQL pour conserver les informations d’état. Lors de la création :
- Activez Azure services et ressources pour accéder à ce serveur (sous Networking). Pour la production, utilisez plutôt des restrictions de pare-feu plus fortes ou des configurations de réseau virtuel .
- Définissez la valeur du classement de base de données (sous Paramètres supplémentaires) sur Latin1_General_100_BIN2_UTF8.

Configurer l’authentification basée sur l’identité

Les identités managées sécurisent votre application en éliminant les secrets de votre application, tels que les informations d’identification dans les chaînes de connexion. Bien que vous puissiez choisir entre l’identité managée affectée par le système et l’identité managée affectée par l’utilisateur, l’identité managée affectée par l’utilisateur est recommandée, car elle n’est pas liée au cycle de vie de l’application.

Dans cette section, vous allez configurer l’identité managée affectée par l’utilisateur pour Stockage Azure.

Définissez les variables d’environnement.

subscription=<SUBSCRIPTION_ID>
identity=<IDENTITY_NAME>

Créez une ressource d’identité managée.

echo "Creating $identity"
az identity create -g $resourceGroup -n $identity --location "$location"

Affectez l’identité de l’utilisateur à l’application conteneur.

echo "Assigning $identity to app"
az containerapp identity assign --resource-group $resourceGroup --name $functionApp --user-assigned $identity

Définissez l’étendue des autorisations de contrôle d’accès en fonction du rôle (RBAC).

scope="/subscriptions/$subscription/resourceGroups/$resourceGroup/providers/Microsoft.Storage/storageAccounts/$storage"

Obtenez l’identité de l’utilisateur clientId.

# Get the identity's ClientId 
clientId=$(az identity show --name $identity --resource-group $resourceGroup --query 'clientId' --output tsv)

Attribuez le rôle Propriétaire des données blob du stockage pour l’accès au compte de stockage.

echo "Assign Storage Blob Data Owner role to identity"
az role assignment create --assignee "$clientId" --role "Storage Blob Data Owner" --scope "$scope"

Configurer les paramètres de l’application

Note

L’authentification auprès de la base de données MSSQL à l’aide de l’identité managée n’est pas prise en charge lors de l’hébergement d’une application Durable Functions dans Azure Container Apps. Pour l’instant, ce guide s’authentifie à l’aide de chaînes de connexion.

À partir de la ressource de base de données SQL dans le portail Azure, accédez auxchaînes de connexion > pour rechercher la chaîne de connexion.

La chaîne de connexion doit avoir un format similaire à :
```
dbserver=<SQL_SERVER_NAME>
sqlDB=<SQL_DB_NAME>
username=<DB_USER_LOGIN>
password=<DB_USER_PASSWORD>

connStr="Server=tcp:$dbserver.database.windows.net,1433;Initial Catalog=$sqlDB;Persist Security Info=False;User ID=$username;Password=$password;MultipleActiveResultSets=False;Encrypt=True;TrustServerCertificate=False;Connection Timeout=30;"
```
Si vous oubliez le mot de passe de l’étape de création de base de données précédente, vous pouvez le réinitialiser sur la ressource SQL Server.
Stockez la chaîne de connexion de la base de données SQL en tant que secret appelé sqldbconnection dans l’application conteneur.
```
az containerapp secret set \
--resource-group $resourceGroup \
--name $functionApp \
--secrets sqldbconnection=$connStr
```

Ajoutez les paramètres suivants à l’application :

az containerapp update \
-n $functionApp \
-g $resourceGroup \
--set-env-vars SQLDB_Connection=secretref:sqldbconnection \
AzureWebJobsStorage__accountName=$storage \
AzureWebJobsStorage__clientId=$clientId \
AzureWebJobsStorage__credential=managedidentity \
FUNCTIONS_WORKER_RUNTIME=dotnet-isolated

Tester l’application Durable Functions déployée

Utilisez un outil de test HTTP pour envoyer une POST requête au point de terminaison du déclencheur HTTP, qui doit être similaire à :
```
https://<APP NAME>.<ENVIRONMENT_IDENTIFIER>.<REGION>.azurecontainerapps.io/api/DurableFunctionsOrchestrationCSharp1_HttpStart
```
La réponse est le résultat initial de la fonction HTTP qui vous indique que l’orchestration Durable Functions a démarré correctement. Bien que la réponse inclut quelques URL utiles, elle n’affiche pas encore le résultat final de l’orchestration.
Copiez/collez la valeur de l'URL pour statusQueryGetUri dans la barre d'adresse de votre navigateur et exécutez. Vous pouvez également continuer à utiliser l’outil de test HTTP pour émettre la GET requête.

La requête interroge l’instance d’orchestration pour obtenir l’état. Vous devriez voir que l’instance s’est terminée et les sorties ou résultats de l’application Durable Functions.
```
{
    "name":"HelloCities",
    "instanceId":"7f99f9474a6641438e5c7169b7ecb3f2",
    "runtimeStatus":"Completed",
    "input":null,
    "customStatus":null,
    "output":"Hello, Tokyo! Hello, London! Hello, Seattle!",
    "createdTime":"2023-01-31T18:48:49Z",
    "lastUpdatedTime":"2023-01-31T18:48:56Z"
}
```

Étapes suivantes

Hébergement des Azure Functions par Azure Container Apps
Architecture du fournisseur de stockage MSSQL, configuration et comportement de la charge de travail
Durable Task Scheduler : le back-end Azure recommandé pour les nouveaux projets de flux de travail durables
Vue d’ensemble de Durable Functions

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-04-28