Tutoriel : Déployer le générateur d’API de données sur Azure Container Apps avec Azure CLI

Le générateur d’API de données peut être rapidement déployé sur des services Azure comme Azure Container Apps dans le cadre de votre pile d’applications. Dans ce tutoriel, vous utilisez Azure CLI pour automatiser les tâches courantes lors du déploiement du générateur d’API de données sur Azure. Tout d’abord, vous créez une image conteneur avec le générateur d’API de données et stockez-la dans Azure Container Registry. Vous déployez ensuite l’image conteneur sur Azure Container Apps avec une base de données Azure SQL en support. L’ensemble du didacticiel s’authentifie auprès de chaque composant à l’aide d’identités managées.

Dans ce tutoriel, vous allez :

Créer une identité managée avec des autorisations de contrôle d’accès en fonction du rôle
Déployer Azure SQL avec l’exemple de jeu de données AdventureWorksLT
Mettre en scène l’image conteneur dans Azure Container Registry
Déployer Azure Container App avec l’image conteneur du générateur d’API de données

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

Conditions préalables

Abonnement Azure

Azure Cloud Shell
- Azure Cloud Shell est un environnement d’interpréteur de commandes interactif que vous pouvez utiliser via votre navigateur. Utilisez cet interpréteur de commandes et ses commandes préinstallées pour exécuter le code dans cet article, sans avoir à installer quoi que ce soit sur votre environnement local. Pour démarrer Azure Cloud Shell :
  - Sélectionnez Essayer dans un code ou un bloc de commandes dans cet article. La sélection de Try ne copie pas automatiquement le code ou la commande dans Cloud Shell.
  - Accédez à https://shell.azure.com, ou sélectionnez Lancer Cloud Shell.
  - Sélectionnez Cloud Shell dans la barre de menus du portail Azure (https://portal.azure.com)

Créer une application conteneur

Tout d’abord, créez une instance Azure Container Apps avec une identité managée affectée par le système. Cette identité finit par recevoir des autorisations de contrôle d'accès basées sur les rôles pour accéder à Azure SQL et Azure Container Registry.

Créez une variable universelle SUFFIX à utiliser pour plusieurs noms de ressources plus loin dans ce tutoriel.
```
let SUFFIX=$RANDOM*$RANDOM
```
Créez une LOCATION variable avec une région Azure que vous avez sélectionnée pour l’utiliser dans ce tutoriel.
```
LOCATION="<azure-region>"
```
Remarque

Par exemple, si vous souhaitez déployer dans la région USA Ouest , vous utiliserez ce script.
```
LOCATION="westus"
```
Pour obtenir la liste des régions prises en charge pour l’abonnement actuel, utilisez az account list-locations
```
az account list-locations --query "[].{Name:displayName,Slug:name}" --output table
```
Pour plus d’informations, consultez Régions Azure.
Créez une variable nommée RESOURCE_GROUP_NAME avec le nom du groupe de ressources. Pour ce tutoriel, nous vous recommandons msdocs-dab-*. Vous utilisez cette valeur plusieurs fois dans ce didacticiel.
```
RESOURCE_GROUP_NAME="msdocs-dab$SUFFIX"    
```

Créez un groupe de ressources en utilisant az group create.

az group create \
  --name $RESOURCE_GROUP_NAME \
  --location $LOCATION \
  --tag "source=msdocs-dab-tutorial"

Créez des variables nommées API_CONTAINER_NAME et CONTAINER_ENV_NAME avec des noms générés de manière unique pour votre instance Azure Container Apps. Vous utilisez ces variables tout au long du didacticiel.
```
API_CONTAINER_NAME="api$SUFFIX"
CONTAINER_ENV_NAME="env$SUFFIX"
```

Utilisez az containerapp env create pour créer un nouvel environnement Azure Container Apps.

az containerapp env create \ 
  --resource-group $RESOURCE_GROUP_NAME \
  --name $CONTAINER_ENV_NAME \
  --logs-destination none \
  --location $LOCATION

Créez une nouvelle application conteneur à l’aide de l’image conteneur DAB mcr.microsoft.com/azure-databases/data-api-builder et la commande az containerapp create. Cette application conteneur s’exécute correctement, mais n’est connectée à aucune base de données.
```
az containerapp create \ 
  --resource-group $RESOURCE_GROUP_NAME \
  --environment $CONTAINER_ENV_NAME \
  --name $API_CONTAINER_NAME \
  --image "mcr.microsoft.com/azure-databases/data-api-builder" \
  --ingress "external" \
  --target-port "5000" \
  --system-assigned
```
Obtenez l’identificateur principal de l’identité managée en utilisant az identity show et stockez la valeur dans une variable nommée MANAGED_IDENTITY_PRINCIPAL_ID.
```
MANAGED_IDENTITY_PRINCIPAL_ID=$( \
  az containerapp show \ 
    --resource-group $RESOURCE_GROUP_NAME \
    --name $API_CONTAINER_NAME \
    --query "identity.principalId" \
    --output "tsv" \
)
```
Conseil / Astuce

Vous pouvez toujours vérifier la sortie de cette commande.
```
echo $MANAGED_IDENTITY_PRINCIPAL_ID
```

Attribuer des autorisations

À présent, affectez les autorisations d’identité managée attribuées par le système pour lire les données à partir d’Azure SQL et d’Azure Container Registry. En outre, attribuez vos autorisations d’identité pour écrire dans Azure Container Registry.

Créez une variable nommée RESOURCE_GROUP_ID pour stocker l’identificateur du groupe de ressources. Obtenez l'identificateur à l'aide de az group show. Vous utilisez cette variable plusieurs fois dans ce didacticiel.
```
RESOURCE_GROUP_ID=$( \
  az group show \
    --name $RESOURCE_GROUP_NAME \
    --query "id" \
    --output "tsv" \
)
```
Conseil / Astuce

Vous pouvez toujours vérifier la sortie de cette commande.
```
echo $RESOURCE_GROUP_ID
```

Permet az role assignment create d’affecter le rôle AcrPush à votre compte afin de pouvoir envoyer des conteneurs à Azure Container Registry.

CURRENT_USER_PRINCIPAL_ID=$( \
  az ad signed-in-user show \
    --query "id" \
    --output "tsv" \
)

# AcrPush
az role assignment create \
  --assignee $CURRENT_USER_PRINCIPAL_ID \
  --role "8311e382-0749-4cb8-b61a-304f252e45ec" \
  --scope $RESOURCE_GROUP_ID

Attribuez le rôle AcrPull à votre identité managée à l’aide az role assignment create de nouveau. Cette affectation permet à l’identité managée d’extraire des images conteneur à partir d’Azure Container Registry. L’identité managée est finalement affectée à une instance Azure Container Apps.
```
# AcrPull    
az role assignment create \
  --assignee $MANAGED_IDENTITY_PRINCIPAL_ID \
  --role "7f951dda-4ed3-4680-a7ca-43fe172d538d" \
  --scope $RESOURCE_GROUP_ID
```

Déployer une base de données

Ensuite, déployez un nouveau serveur et une base de données dans le service Azure SQL. La base de données utilise le jeu de données d'exemple AdventureWorksLT.

Créez une variable nommée SQL_SERVER_NAME avec un nom généré de manière unique pour votre instance de serveur Azure SQL. Vous utilisez cette variable plus loin dans cette section.
```
SQL_SERVER_NAME="srvr$SUFFIX"
```

Créez une nouvelle ressource Azure SQL "Server" à l’aide de . Configurez l’identité managée en tant qu’administrateur de ce serveur.

az sql server create \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $SQL_SERVER_NAME \
  --location $LOCATION \
  --enable-ad-only-auth \
  --external-admin-principal-type "User" \
  --external-admin-name $API_CONTAINER_NAME \
  --external-admin-sid $MANAGED_IDENTITY_PRINCIPAL_ID

Permet az sql server firewall-rule create de créer une règle de pare-feu pour autoriser l’accès à partir des services Azure.

az sql server firewall-rule create \
  --resource-group $RESOURCE_GROUP_NAME \
  --server $SQL_SERVER_NAME \
  --name "AllowAzure" \
  --start-ip-address "0.0.0.0" \
  --end-ip-address "0.0.0.0"

Permet az sql db create de créer une base de données dans le serveur Azure SQL nommé adventureworks. Configurez la base de données pour utiliser les données d'exemple de AdventureWorksLT.
```
az sql db create \
  --resource-group $RESOURCE_GROUP_NAME \
  --server $SQL_SERVER_NAME \
  --name "adventureworks" \
  --sample-name "AdventureWorksLT"
```
Créez une variable nommée SQL_CONNECTION_STRING avec la chaîne de connexion de la adventureworks base de données dans votre instance de serveur Azure SQL. Construisez la chaîne de connexion avec le nom de domaine complet du serveur en utilisant az sql server show. Vous utilisez cette variable plus loin dans ce tutoriel.
```
SQL_SERVER_ENDPOINT=$( \
  az sql server show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $SQL_SERVER_NAME \
    --query "fullyQualifiedDomainName" \
    --output "tsv" \
)

SQL_CONNECTION_STRING="Server=$SQL_SERVER_ENDPOINT;Database=adventureworks;Encrypt=true;Authentication=Active Directory Default;"
```
Conseil / Astuce

Vous pouvez toujours vérifier la sortie de cette commande.
```
echo $SQL_CONNECTION_STRING
```

Générer l’image conteneur

Ensuite, générez une image conteneur à l’aide d’un fichier Dockerfile. Déployez ensuite cette image conteneur sur une instance Azure Container Registry nouvellement créée.

Créez une variable nommée CONTAINER_REGISTRY_NAME avec un nom généré de manière unique pour votre instance Azure Container Registry. Vous utilisez cette variable plus loin dans cette section.
```
CONTAINER_REGISTRY_NAME="reg$SUFFIX"
```

Créez une instance Azure Container Registry à l'aide de az acr create.

az acr create \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $CONTAINER_REGISTRY_NAME \
  --sku "Standard" \
  --location $LOCATION \
  --admin-enabled false

Créez un fichier Dockerfile à plusieurs étapes nommé Dockerfile. Dans le fichier, implémentez ces étapes.
- Utiliser l’image de conteneur mcr.microsoft.com/dotnet/sdk comme base de la phase de construction.
- Installez l’interface CLI DAB.
- Créez un fichier de configuration pour une connexion de base de données SQL (mssql) à l’aide de la DATABASE_CONNECTION_STRING variable d’environnement comme chaîne de connexion.
- Créez une entité nommée Product mappée à la SalesLT.Product table.
- Copiez le fichier de configuration dans l’image conteneur finale mcr.microsoft.com/azure-databases/data-api-builder .
```
FROM mcr.microsoft.com/dotnet/sdk:8.0-cbl-mariner2.0 AS build

WORKDIR /config

RUN dotnet new tool-manifest

RUN dotnet tool install Microsoft.DataApiBuilder

RUN dotnet tool run dab -- init --database-type "mssql" --connection-string "@env('DATABASE_CONNECTION_STRING')"

RUN dotnet tool run dab -- add Product --source "SalesLT.Product" --permissions "anonymous:read"

FROM mcr.microsoft.com/azure-databases/data-api-builder:latest

COPY --from=build /config /App
```

Construisez le Dockerfile comme une tâche Azure Container Registry à l'aide de az acr build.

az acr build \
  --registry $CONTAINER_REGISTRY_NAME \
  --image adventureworkslt-dab:latest \
  --image adventureworkslt-dab:{{.Run.ID}} \
  --file Dockerfile \
  .

Permet az acr show d’obtenir le point de terminaison du registre de conteneurs et de le stocker dans une variable nommée CONTAINER_REGISTRY_LOGIN_SERVER.
```
CONTAINER_REGISTRY_LOGIN_SERVER=$( \
  az acr show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $CONTAINER_REGISTRY_NAME \
    --query "loginServer" \
    --output "tsv" \
)
```
Conseil / Astuce

Vous pouvez toujours vérifier la sortie de cette commande.
```
echo $CONTAINER_REGISTRY_LOGIN_SERVER
```

Déployer une image conteneur

Enfin, mettez à jour Azure Container App avec la nouvelle image de conteneur personnalisée et les informations d’identification. Testez l’application en cours d’exécution pour valider sa connectivité à la base de données.

Configurez l’application conteneur pour utiliser le registre de conteneurs en utilisant az containerapp registry set.

az containerapp registry set \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $API_CONTAINER_NAME \
  --server $CONTAINER_REGISTRY_LOGIN_SERVER \
  --identity "system"

Utilisez az containerapp secret set pour créer un secret nommé conn-string avec la chaîne de connexion Azure SQL.
```
az containerapp secret set \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $API_CONTAINER_NAME \
  --secrets conn-string="$SQL_CONNECTION_STRING"
```
Important

Cette chaîne de connexion n’inclut aucun nom d’utilisateur ou mot de passe. La chaîne de connexion utilise l’identité managée pour accéder à la base de données Azure SQL. Cela permet d’utiliser la chaîne de connexion en tant que secret dans l’hôte.
Mettez à jour l'application conteneur avec votre nouvelle image personnalisée de conteneur à l'aide de az containerapp update. Définissez la DATABASE_CONNECTION_STRING variable d'environnement afin de lire le secret conn-string précédemment créé.
```
az containerapp update \
  --resource-group $RESOURCE_GROUP_NAME \
  --name $API_CONTAINER_NAME \
  --image "$CONTAINER_REGISTRY_LOGIN_SERVER/adventureworkslt-dab:latest" \
  --set-env-vars DATABASE_CONNECTION_STRING=secretref:conn-string
```
Récupérez le nom de domaine complet de la dernière révision dans l'application de conteneur qui est en cours d'exécution à l'aide de az containerapp show. Stockez cette valeur dans une variable nommée APPLICATION_URL.
```
APPLICATION_URL=$( \
  az containerapp show \
    --resource-group $RESOURCE_GROUP_NAME \
    --name $API_CONTAINER_NAME \
    --query "properties.latestRevisionFqdn" \
    --output "tsv" \
)
```
Conseil / Astuce

Vous pouvez toujours vérifier la sortie de cette commande.
```
echo $APPLICATION_URL
```
Accédez à l’URL et testez l’API Product REST.
```
echo "https://$APPLICATION_URL/api/Product"
```
Avertissement

Le déploiement peut prendre jusqu’à une minute. Si vous ne voyez pas de réponse réussie, attendez et actualisez votre navigateur.

Nettoyer les ressources

Lorsque vous n’avez plus besoin de l’exemple d’application ou de ressources, supprimez le déploiement correspondant et toutes les ressources.

az group delete \
  --name $RESOURCE_GROUP_NAME

Étape suivante

Utiliser Application Insights avec le générateur d’API de données

Commentaires

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

Last updated on 2025-07-17