Gérer des groupes de ressources Azure avec l’API de fonction TypeScript
Dans ce tutoriel, vous allez créer une application de fonction Azure TypeScript locale avec des API pour gérer des groupes de ressources Azure et déployer l’application sur Azure.
Fonctionnalités et fonctionnalités :
- Créer un projet d’application de fonction Azure TypeScript local dans Visual Studio Code
- Créer du code réutilisable de l’API de fonction dans Visual Studio Code
- Déployer sur Azure Functions à partir de Visual Studio Code
- Créer un principal du service avec l’interface de ligne de commande Azure
- Configurer les paramètres d’application locale et distante avec Visual Studio Code
- Utiliser DefaultAzureCredential dans les environnements locaux et distants pour les connexions sans mot de passe
- Utiliser les kits SDK Azure Identity et Azure Resource Management pour gérer les ressources Azure
- Utiliser vos API locales et cloud pour créer, supprimer et lister les groupes de ressources dans votre abonnement
Comme le code source est écrit avec TypeScript, il est simple. Si vous êtes à l’aise avec javaScript moderne à l’aide d’async/await, le code vous sera familier.
Créer ou utiliser un abonnement Azure existant
Vous devez disposer d’un compte d’utilisateur Azure avec un abonnement actif. Créez-en un gratuitement.
Prérequis
- Node.js LTS 18+ et npm installés sur votre ordinateur local. Votre version d’environnement de développement local de Node.js doit correspondre à l’une des versions disponibles du runtime cloud Azure Function.
- Visual Studio Code installé sur votre ordinateur local.
- Extension de fonction Azure v1.10.4 ou ultérieure.
- Azure Functions Core Tools v4.0.5095 ou version ultérieure
- Azure Cloud Shell ou Azure CLI installé sur votre ordinateur local.
Architecture de l'application
L’application fournit les points de terminaison d’API suivants.
Méthode | URL | Description |
---|---|---|
POST,DELETE | http://localhost:7071/api/resourcegroup | Ajoutez ou supprimez un groupe de ressources. Lors de l’ajout, incluez des balises (paires clé/valeur) pour identifier l’objectif du groupe ultérieurement. |
GET | http://localhost:7071/api/resourcegroups | Lister tous les groupes de ressources dans un abonnement. |
GET | http://localhost:7071/api/resources | Lister toutes les ressources dans un abonnement ou un groupe de ressources. |
Bien que ces points de terminaison soient publics, vous devez sécuriser vos points de terminaison d’API avec l’authentification et l’autorisation avant de les déployer dans votre environnement en direct.
Cette application est limitée à un abonnement, car il s’agit de l’étendue spécifiée lors de la création du principal de service.
1. Préparation de votre environnement
Vous devez préparer vos environnements locaux et cloud pour utiliser le kit SDK Azure Identity.
Connectez-vous à Azure CLI
Dans un terminal bash, connectez-vous à Azure CLI avec la commande suivante :
az login
Obtenir votre ID d’abonnement Azure
Dans un terminal bash, obtenez vos abonnements et recherchez l’ID d’abonnement que vous souhaitez utiliser. La requête suivante retourne l’ID d’abonnement, le nom de l’abonnement et l’ID de locataire triés par nom d’abonnement.
az account list --query "sort_by([].{Name:name, SubscriptionId:id, TenantId:tenantId}, &Name)" --output table
Copiez l’ID d’abonnement dans le fichier temporaire précédent. Vous aurez besoin de ce paramètre ultérieurement.
Créer un principal du service Azure
Un principal de service Azure permet d’accéder à Azure sans avoir à utiliser vos informations d’identification d’utilisateur personnelles. Pour ce tutoriel, le principal de service peut être utilisé à la fois dans vos environnements locaux et cloud. Dans un environnement d’entreprise, vous souhaitez séparer les principaux de service pour chaque environnement.
Déterminez un format de nom de principal de service afin de pouvoir retrouver facilement votre principal de service par la suite. Par exemple, voici plusieurs idées de format :
- Votre projet et le propriétaire :
resource-management-john-smith
. - Votre service et la date :
IT-2021-September
- Un identificateur unique :
00000000-0000-0000-0000-000000000000
- Votre projet et le propriétaire :
Dans un terminal bash, créez votre principal de service avec az ad sp create-for-rbac. Remplacez
<SUBSCRIPTION-ID>
par votre ID d’abonnement.az ad sp create-for-rbac --name YOUR-SERVICE-PRINCIPAL-NAME --role Contributor --scopes /subscriptions/<SUBSCRIPTION-ID>
Copiez l’intégralité des résultats de sortie dans un fichier temporaire. Vous aurez besoin de ces paramètres ultérieurement.
{ "appId": "YOUR-SERVICE-PRINCIPAL-ID", "displayName": "YOUR-SERVICE-PRINCIPAL-NAME", "name": "http://YOUR-SERVICE-PRINCIPAL-NAME", "password": "YOUR-SERVICE-PRINCIPAL-PASSWORD", "tenant": "YOUR-TENANT-ID" }
2. Créer une application de fonction Azure locale dans Visual Studio Code
Créez une application de fonction Azure dans Visual Studio Code pour gérer des groupes de ressources Azure.
Créer une application de fonction
Utilisez Visual Studio Code pour créer une application de fonction locale.
Dans un terminal bash, créez et remplacez par un nouveau répertoire :
mkdir my-function-app && cd my-function-app
Dans un terminal bash, ouvrez Visual Studio Code :
code .
Ouvrez la palette de commandes Visual Studio Code : Ctrl + Maj + p.
Entrez
Azure Functions: create new project
. Utilisez le tableau suivant pour terminer les invites :Prompt Valeur Sélectionnez le dossier qui contiendra votre projet de fonction Sélectionnez le répertoire par défaut (actif) Sélectionner une langue Sélectionnez TypeScript. Sélectionner un modèle de programmation TypeScript Sélectionner le modèle V4 (préversion) Sélectionner un modèle pour la première fonction de votre projet Sélectionnez Déclencheur HTTP. Créer un déclencheur HTTP Entrez le nom de l’API resourcegroups
.Niveau d’autorisation Sélectionnez Anonyme. Si vous continuez avec ce projet après cet article, remplacez le niveau d’autorisation par la fonction. En savoir plus sur l’autorisation de niveau fonction. Le projet réutilisable est créé et les dépendances sont installées.
Ajouter des paramètres de principal de service au fichier local.settings.json
Ouvrez le
./local.settings.json
fichier dans le répertoire racine du projet et ajoutez votre section VALUES avec les cinq variables d’environnement suivantes.{ "IsEncrypted": false, "Values": { "AzureWebJobsStorage": "", "FUNCTIONS_WORKER_RUNTIME": "node", "AzureWebJobsFeatureFlags": "EnableWorkerIndexing", "AZURE_CLIENT_ID": "REPLACE-WITH-SERVICE-PRINCIPAL-APPID", "AZURE_CLIENT_SECRET": "REPLACE-WITH-SERVICE-PRINCIPAL-PASSWORD", "AZURE_SUBSCRIPTION_ID":"REPLACE-WITH-SUBSCRIPTION-ID", "AZURE_TENANT_ID":"REPLACE-WITH-SERVICE-PRINCIPAL-TENANT", "NODE_ENV":"development" } }
Reportez-vous à vos paramètres de la section précédente pour ajouter les valeurs. Ces variables d’environnement sont OBLIGATOIRES pour que le contexte utilise DefaultAzureCredential.
AZURE_TENANT_ID
:tenant
de la sortie du principal de service ci-dessus.AZURE_CLIENT_ID
:appId
de la sortie du principal de service ci-dessus.AZURE_CLIENT_SECRET
:password
de la sortie du principal de service ci-dessus.
Vous devez également définir l’ID d’abonnement. Il est nécessaire d’utiliser le Kit de développement logiciel (SDK) Azure pour la gestion des ressources.
AZURE_SUBSCRIPTION_ID
: Votre abonnement par défaut contenant vos groupes de ressources.
Ce fichier local.settings.json
est ignoré par votre git local volontairement, donc vous ne pouvez pas le commiter par erreur dans votre code source.
Installer les dépendances npm pour la gestion des identités et des ressources Azure
Dans un terminal bash intégré Visual Studio Code, installez les dépendances du kit SDK Azure pour la gestion des identités et des ressources Azure.
npm install @azure/identity @azure/arm-resources
Lister tous les groupes de ressources dans un abonnement avec JavaScript
Ouvrez le fichier
./src/functions/resourcegroups.ts
et remplacez le contenu par le contenu suivant :import { ResourceGroup } from '@azure/arm-resources'; import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions'; import { createResourceGroup, deleteResourceGroup } from '../lib/azure-resource-groups'; import { processError } from '../lib/error'; export async function resourcegroup( request: HttpRequest, context: InvocationContext ): Promise<HttpResponseInit> { try { console.log(JSON.stringify(request.query)); console.log(JSON.stringify(request.params)); const name: string = request.query.get('name'); const location: string = request.query.get('location'); console.log(`name: ${name}`); console.log(`location: ${location}`); switch (request.method) { case 'POST': // wait for create to complete before returning if (!name || !location) { return { body: 'Missing required parameters.', status: 400 }; } if (request.headers.get('content-type') === 'application/json') { // create with tags const body: Record<string, unknown> = (await request.json()) as Record<string, string>; const tags: Record<string, string> = body?.tags ? (body?.tags as Record<string, string>) : null; const resourceGroup: ResourceGroup = await createResourceGroup( name, location, tags ); return { jsonBody: resourceGroup, status: 200 }; } else { // create without tags const resourceGroup: ResourceGroup = await createResourceGroup( name, location, null ); return { jsonBody: resourceGroup, status: 200 }; } case 'DELETE': // wait for delete to complete before returning if (!name) { return { body: 'Missing required parameters.', status: 400 }; } await deleteResourceGroup(name); return { status: 204 }; } } catch (err: unknown) { return processError(err); } } app.http('resourcegroup', { methods: ['DELETE', 'POST'], authLevel: 'anonymous', handler: resourcegroup });
Ce fichier répond aux demandes d’API et
/api/resourcegroups
retourne une liste de tous les groupes de ressources de l’abonnement.Créez un sous-répertoire dans
src
nommélib
et créez un fichier dans ce répertoire nomméazure-resource-groups.ts
.Copiez le code suivant dans le fichier
./src/lib/azure-resource-groups.ts
:// Include npm dependencies import { ResourceGroup, ResourceManagementClient } from '@azure/arm-resources'; import { DefaultAzureCredential } from '@azure/identity'; import { getSubscriptionId } from './environment-vars'; const subscriptionId = getSubscriptionId(); // Create Azure authentication credentials const credentials = new DefaultAzureCredential(); // Create Azure SDK client for Resource Management such as resource groups const resourceManagement = new ResourceManagementClient( credentials, subscriptionId ); // all resources groups in subscription export const listResourceGroups = async (): Promise<{ list: ResourceGroup[]; subscriptionId: string; }> => { const list: ResourceGroup[] = []; for await (const resourceGroup of resourceManagement.resourceGroups.list()) { list.push(resourceGroup); } return { subscriptionId, list }; }; export const createResourceGroup = async ( resourceGroupName: string, location: string, tags: { [propertyName: string]: string } ): Promise<ResourceGroup> => { const resourceGroupParameters = { location: location, tags }; return await resourceManagement.resourceGroups.createOrUpdate( resourceGroupName, resourceGroupParameters ); }; export const deleteResourceGroup = async ( resourceGroupName: string ): Promise<void> => { return await resourceManagement.resourceGroups.beginDeleteAndWait( resourceGroupName ); };
Ce fichier :
- Obtient l’ID d’abonnement.
- Crée le contexte DefaultAzureCredential.
- Crée le ResourceManagementClient requis pour utiliser le kit SDK de gestion des ressources.
- Obtient tous les groupes de ressources de l’abonnement.
Créez un fichier dans le
./src/lib
répertoire nomméenvironment-vars.ts
et copiez le code suivant dans ce fichier.export const checkAzureAuth = () => { // The following code is only used to check you have environment // variables configured. The DefaultAzureCredential reads your // environment - it doesn't read these variables. const tenantId = process.env['AZURE_TENANT_ID']; if (!tenantId) throw Error('AZURE_TENANT_ID is missing from environment variables.'); const clientId = process.env['AZURE_CLIENT_ID']; if (!clientId) throw Error('AZURE_CLIENT_ID is missing from environment variables.'); const secret = process.env['AZURE_CLIENT_SECRET']; if (!secret) throw Error('AZURE_CLIENT_SECRET is missing from environment variables.'); }; export const getSubscriptionId = (): string => { checkAzureAuth(); // Get subscription from environment variables const subscriptionId = process.env['AZURE_SUBSCRIPTION_ID']; if (!subscriptionId) throw Error('Azure Subscription is missing from environment variables.'); return subscriptionId; };
Ce fichier vérifie les variables d’environnement avant de retourner l’ID d’abonnement.
Créez un fichier dans le
./src/lib
répertoire nomméerror.ts
et copiez le code suivant dans ce fichier.export function processError(err: unknown): any { if (typeof err === 'string') { return { body: err.toUpperCase(), status: 500 }; } else if ( err['stack'] && process.env.NODE_ENV.toLowerCase() !== 'production' ) { return { jsonBody: { stack: err['stack'], message: err['message'] } }; } else if (err instanceof Error) { return { body: err.message, status: 500 }; } else { return { body: JSON.stringify(err) }; } }
Ce fichier retourne une erreur 500 avec le message d’erreur. La pile est retournée si la
NODE_ENV
variable n’est pas définie surproduction
.
Tester les fonctions locales
Dans le terminal intégré Visual Studio Code, exécutez le projet local :
npm start
Attendez que le terminal bash intégré affiche l’URL de la fonction en cours d’exécution.
Ouvrez un deuxième terminal bash intégré dans Visual Studio Code, Ctrl + Maj + 5 et utilisez la commande GET cURL suivante pour utiliser l’API :
curl http://localhost:7071/api/resourcegroups
Si vous avez un grand nombre de groupes de ressources dans votre abonnement, vous souhaiterez peut-être diriger la sortie vers un fichier pour en faciliter la révision.
curl http://localhost:7071/api/resourcegroups > resourcegroups.json
La réponse inclut
subscriptionId
et unlist
de tous les groupes de ressources de cet abonnement.{ "subscriptionId": "ABC123", "list": [ { "id": "/subscriptions/ABC123/resourceGroups/vmagelo-cloudshell", "name": "jsmith-cloudshell", "type": "Microsoft.Resources/resourceGroups", "properties": { "provisioningState": "Succeeded" }, "location": "westeurope" }, ... REMOVED FOR BREVITY ... ] }
Dépannage
Si vous n’avez pas pu suivre cet article, consultez le tableau suivant pour connaître les problèmes éventuels. Si votre problème n’est pas listé dans le tableau, ouvrez un problème sur cette page de documentation.
Problème | Correctif |
---|---|
L’application n’a pas démarré. | Examinez les erreurs. Veillez à installer les dépendances requises. |
L’application a démarré, mais vous ne pouvez pas obtenir une réponse 200. | Assurez-vous que la commande cURL demande depuis la bonne route locale. |
L’API a retourné une réponse 200, mais n’a retourné aucun résultat. | Utilisez l’extension Visual Studio Code Azure Resources pour vérifier que votre abonnement a des groupes de ressources. Si vous ne voyez aucun groupe de ressources, ne vous inquiétez pas. Ce tutoriel ajoute une API pour créer et supprimer des groupes de ressources dans votre abonnement. Cette API est ajoutée après le premier déploiement du code source dans Azure, ce qui vous apprend à redéployer votre code. |
3. Créer une application de fonction Azure basée sur le cloud
Dans Visual Studio Code, sélectionnez l’icône Azure pour ouvrir l’Explorateur Azure.
Sélectionnez l’icône + pour créer une application De fonction Azure dans le cloud Azure.
Sélectionnez Créer une application de fonction dans Azure.
Entrez un nom global unique pour la nouvelle application de fonction. Le nom doit être unique dans toutes les fonctions Azure. Par exemple :
jsmith-rg-management
.Sélectionnez le même runtime Node.js 18+ LTS que vous avez sélectionné lors de la création de votre application de fonction locale.
Sélectionnez un emplacement géographique proche de vous, par exemple USA Ouest 3.
Attendez que la ressource soit créée. Vous pouvez regarder Azure : Journal d’activité pour plus d’informations.
4. Configurer l’application de fonction Azure basée sur le cloud
Vous devez configurer les paramètres de votre application Azure pour qu’elle se connecte à l’application de fonction Azure. Localement, ces paramètres se trouvent dans votre fichier local.settings.json
. Ce processus ajoute ces valeurs à votre application cloud.
Dans Visual Studio Code, dans l’Explorateur Azure, dans la section Ressources , développez l’application de fonction, puis sélectionnez votre application de fonction.
Cliquez avec le bouton droit sur Paramètres d’application et sélectionnez Ajouter un nouveau paramètre.
Ajoutez les quatre valeurs de votre fichier
local.settings.json
avec exactement le même nom et les mêmes valeurs.AZURE_TENANT_ID
:tenant
de la sortie du principal de service ci-dessus.AZURE_CLIENT_ID
:appId
de la sortie du principal de service ci-dessus.AZURE_CLIENT_SECRET
:password
de la sortie du principal de service ci-dessus.AZURE_SUBSCRIPTION_ID
: Votre abonnement par défaut contenant vos groupes de ressources.AzureWebJobsFeatureFlags
:EnableWorkerIndexing
5. Déployer l’application de fonction Resource Manager
Déployez une application de fonction Azure dans Visual Studio Code pour gérer des groupes de ressources Azure.
Utiliser l’extension Visual Studio Code pour le déploiement sur l’environnement d’hébergement
Dans VS Code, ouvrez le
local.settings.json
fichier afin qu’il soit visible. Cela facilite la copie de ces noms et valeurs.Sélectionnez le logo Azure pour ouvrir l’Explorateur Azure, puis, sous Functions, sélectionnez l’icône cloud pour déployer votre application.
Vous pouvez aussi déployer en ouvrant la Palette de commandes avec Ctrl + Maj + p, entrant
deploy to function app
et en exécutant la commande Azure Functions: Deploy to Function App.Sélectionnez Déployer sur l’application de fonction.
Sélectionnez le nom de l’application de fonction que vous avez créé dans la section précédente.
Lorsque vous êtes sûr de vouloir déployer, sélectionnez Déployer.
Le panneau Sortie de VS Code pour Azure Functions montre la progression. Lors du déploiement, la totalité de l’application Functions est déployée : les changements apportés à toutes les fonctions individuelles sont donc déployés en même temps.
Vérifier que l’application Functions est disponible avec un navigateur
Toujours dans Visual Studio Code, accédez à l’Explorateur Azure Functions, développez le nœud de votre abonnement Azure, le nœud de votre application Functions, puis Fonctions (lecture seule). Cliquez avec le bouton droit sur le nom de la fonction et sélectionnez Copier l’URL de la fonction :
Collez l’URL dans un navigateur, puis appuyez sur Entrée pour demander la liste des groupes de ressources à partir de l’API cloud.
6. Ajouter des API à l’application de fonction et redéployer dans Azure
Ajoutez les API suivantes, puis redéployez votre application de fonction Azure dans Visual Studio Code :
- Ajouter et supprimer des groupes de ressources
- Répertorier les ressources dans un groupe de ressources ou un abonnement.
À ce stade du tutoriel, vous avez créé une application de fonction locale avec une API pour répertorier les groupes de ressources de votre abonnement et vous avez déployé cette application sur Azure. En tant que développeur Azure, vous voulez créer ou supprimer des groupes de ressources dans le cadre de votre pipeline d’automatisation des processus.
Créer une API resourcegroup pour votre application de fonction
Utilisez l’extension Visual Studio Code pour Azure Functions pour ajouter les fichiers TypeScript à votre application de fonction pour créer et supprimer des groupes de ressources.
Ouvrez la palette de commandes Visual Studio Code : Ctrl + Maj + p.
Entrez
Azure Functions: Create Function
, puis appuyez sur entrée pour commencer le processus.Utilisez le tableau suivant pour créer l’API /api/resourcegroup :
Prompt Valeur Sélectionner un modèle pour votre fonction Déclencheur HTTP Fournir un nom de fonction resourcegroup
Niveau d’autorisation Sélectionnez Anonyme. Si vous poursuivez avec ce projet, remplacez le niveau d’autorisation par la fonction. En savoir plus sur l’autorisation de niveau fonction. Ouvrez et
./src/functions/resourcegroup.ts
remplacez l’intégralité du fichier par le code source suivant.import { ResourceGroup } from '@azure/arm-resources'; import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions'; import { createResourceGroup, deleteResourceGroup } from '../lib/azure-resource-groups'; import { processError } from '../lib/error'; export async function resourcegroup( request: HttpRequest, context: InvocationContext ): Promise<HttpResponseInit> { try { console.log(JSON.stringify(request.query)); console.log(JSON.stringify(request.params)); const name: string = request.query.get('name'); const location: string = request.query.get('location'); console.log(`name: ${name}`); console.log(`location: ${location}`); switch (request.method) { case 'POST': // wait for create to complete before returning if (!name || !location) { return { body: 'Missing required parameters.', status: 400 }; } if (request.headers.get('content-type') === 'application/json') { // create with tags const body: Record<string, unknown> = (await request.json()) as Record<string, string>; const tags: Record<string, string> = body?.tags ? (body?.tags as Record<string, string>) : null; const resourceGroup: ResourceGroup = await createResourceGroup( name, location, tags ); return { jsonBody: resourceGroup, status: 200 }; } else { // create without tags const resourceGroup: ResourceGroup = await createResourceGroup( name, location, null ); return { jsonBody: resourceGroup, status: 200 }; } case 'DELETE': // wait for delete to complete before returning if (!name) { return { body: 'Missing required parameters.', status: 400 }; } await deleteResourceGroup(name); return { status: 204 }; } } catch (err: unknown) { return processError(err); } } app.http('resourcegroup', { methods: ['DELETE', 'POST'], authLevel: 'anonymous', handler: resourcegroup });
Le
./src/lib/azure-resource-groups.ts
fichier contient déjà le code permettant d’ajouter et de supprimer des groupes de ressources.
Créer une API de ressources pour votre application de fonction
Utilisez l’extension Visual Studio Code pour Azure Functions pour ajouter les fichiers TypeScript à votre application de fonction pour répertorier les ressources d’un groupe de ressources.
Ouvrez la palette de commandes Visual Studio Code : Ctrl + Maj + p.
Entrez
Azure Functions: Create Function
, puis appuyez sur entrée pour commencer le processus.Utilisez le tableau suivant pour créer l’API /api/resources :
Prompt Valeur Sélectionner un modèle pour votre fonction Déclencheur HTTP Fournir un nom de fonction resources
Niveau d’autorisation Sélectionnez Anonyme. Si vous poursuivez avec ce projet, remplacez le niveau d’autorisation par la fonction. En savoir plus sur l’autorisation de niveau fonction. Ouvrez et
./src/functions/resources.ts
remplacez l’intégralité du fichier par le code source suivant.import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions'; import { listResourceByResourceGroup, listResourceBySubscription } from '../lib/azure-resource'; import { processError } from '../lib/error'; export async function resources( request: HttpRequest, context: InvocationContext ): Promise<HttpResponseInit> { try { const resourceGroupName: string = request.query.get('resourceGroupName'); context.log(`resourceGroupName: '${resourceGroupName}'`); if (resourceGroupName) { const resourcesByName = await listResourceByResourceGroup( resourceGroupName ); return { jsonBody: resourcesByName }; } else { const resourcesBySubscription = await listResourceBySubscription(); return { jsonBody: resourcesBySubscription }; } } catch (err: unknown) { return processError(err); } } app.http('resources', { methods: ['GET'], authLevel: 'anonymous', handler: resources });
Créez le
./src/lib/azure-resource.ts
fichier et copiez le code suivant dans celui-ci pour répertorier les ressources d’un groupe de ressources.// Include npm dependencies import { Resource, ResourceManagementClient } from '@azure/arm-resources'; import { DefaultAzureCredential } from '@azure/identity'; import { getSubscriptionId } from './environment-vars'; const subscriptionId = getSubscriptionId(); // Create Azure authentication credentials const credentials = new DefaultAzureCredential(); // Create Azure SDK client for Resource Management such as resource groups const resourceManagement = new ResourceManagementClient( credentials, subscriptionId ); // all resources groups in subscription export const listResourceBySubscription = async (): Promise<{ list: Resource[]; subscriptionId: string; }> => { const list: Resource[] = []; for await (const resource of resourceManagement.resources.list()) { list.push(resource); } return { subscriptionId, list }; }; // all resources groups in resource group export const listResourceByResourceGroup = async ( resourceGroupName: string ): Promise<{ list: Resource[]; subscriptionId: string; resourceGroupName: string; }> => { const list: Resource[] = []; for await (const resource of resourceManagement.resources.listByResourceGroup( resourceGroupName )) { list.push(resource); } return { subscriptionId, resourceGroupName, list }; };
Démarrer votre application de fonction locale et tester la nouvelle API
Dans le terminal intégré Visual Studio Code, exécutez le projet local :
npm start
Attendez que le terminal bash intégré affiche l’URL de la fonction en cours d’exécution.
Utilisez les commandes curl suivantes dans un autre terminal bash intégré, pour appeler votre API, pour ajouter un groupe de ressources à votre abonnement. Changez le nom du groupe de ressources en utilisant vos propres conventions de nommage.
curl -X POST 'http://localhost:7071/api/resourcegroup?name=my-test-1&location=westus' curl -X POST 'http://localhost:7071/api/resourcegroup?name=my-test-1&location=westus' \ -H 'content-type: application/json' \ -d '{"tags": {"a":"b"}}'
Utilisez la commande curl suivante pour afficher le nouveau groupe de ressources listé dans votre abonnement.
curl http://localhost:7071/api/resource-groups
Utilisez la commande curl suivante pour supprimer le groupe de ressources que vous venez d’ajouter.
curl -X DELETE 'http://localhost:7071/api/resourcegroup?name=my-test-1' \ -H 'Content-Type: application/json'
Redéployer votre application de fonction avec les nouvelles API sur Azure
Dans VS Code, déployez en ouvrant la palette de commandes avec Ctrl + Maj + p, en entrant
deploy to function app
et en exécutant la commande Azure Functions : Déployer sur l’application de fonction.Sélectionnez votre application de fonction dans la liste des applications.
Sélectionnez Déployer dans la fenêtre contextuelle.
Attendez la fin du déploiement.
Vérifier les API de fonction avec le navigateur
Utilisez les commandes cURL précédentes, en remplaçant l’adresse localhost, http://localhost:7071
par le nom de votre ressource De fonction Azure, par exemple https://myfunction.azurewebsites.net
.
7. Afficher et interroger les journaux de votre application de fonction
Affichez et interrogez les journaux d’activité de l’application de fonction Azure dans le Portail Azure.
Interroger vos journaux de fonctions Azure
Utilisez le portail Azure pour afficher et interroger vos journaux de fonction.
Dans VS Code, sélectionnez le logo Azure pour ouvrir l’Explorateur Azure. Sous Fonctions, cliquez avec le bouton droit sur votre application de fonction, puis sélectionnez Ouvrir dans le portail.
Le portail Azure s’ouvrira alors sur votre fonction Azure.
Sélectionnez Application Insights dans les paramètres, puis sélectionnez Voir les données Application Insights.
Ce lien vous permet d’accéder à la ressource de métriques qui a été créée lorsque vous avez créé votre fonction Azure avec VS Code.
Sélectionnez Journaux dans la section Supervision. Si une fenêtre contextuelle Requêtes s’affiche, sélectionnez la croix (X) dans le coin supérieur droit de la fenêtre pour la fermer.
Dans le volet Schéma et filtre, sous l’onglet Tables, double-cliquez sur la table traces.
La requête Kusto
traces
est alors entrée dans la fenêtre de requête.Modifiez la requête pour rechercher des appels d’API :
traces | where message startswith "Executing "
Sélectionnez Exécuter.
Si le journal n’affiche aucun résultat, cela peut être dû au fait qu’il existe quelques minutes de retard entre la requête HTTP vers la fonction Azure et la disponibilité du journal dans Kusto. Patientez quelques minutes avant de réexécuter la requête.
Étant donné qu’une ressource application Recommandations a été ajoutée pour vous lorsque vous avez créé l’application de fonction Azure, vous n’avez pas besoin d’effectuer d’autres opérations supplémentaires pour obtenir ces informations de journalisation :
- L’application de fonction a ajouté Application Insights pour vous.
- L’outil de requête est inclus dans le portail Azure.
- Vous pouvez sélectionner
traces
au lieu d’avoir à apprendre à écrire une requête Kusto pour obtenir même les informations minimales de vos journaux d’activité.
8. Nettoyer les ressources Azure
Supprimer le groupe de ressources
Dans VS Code, sélectionnez le logo Azure pour ouvrir l’Explorateur Azure, puis, sous Functions, cliquez avec le bouton droit sur votre application de fonction, puis sélectionnez Ouvrir dans le portail. Cela ouvre la Portail Azure à votre fonction Azure.
Dans la section Vue d’ensemble, recherchez et sélectionnez le nom du groupe de ressources. Cette action vous dirige vers le groupe de ressources dans le Portail Azure.
La page groupe de ressources répertorie toutes les ressources associées à ce didacticiel.
Dans le menu supérieur, sélectionnez Supprimer le groupe de ressources.
Dans le menu latéral, entrez le nom du groupe de ressources, puis sélectionnez Supprimer.
Supprimer le principal de service
Pour supprimer le principal de service, exécutez la commande suivante. Remplacez <YOUR-SERVICE-PRINCIPAL-NAME>
par le nom de votre principal de service.
az ad sp delete --id <YOUR-SERVICE-PRINCIPAL-NAME>
Exemple de code
Étapes suivantes
Commentaires
https://aka.ms/ContentUserFeedback.
Prochainement : Tout au long de l'année 2024, nous supprimerons progressivement les GitHub Issues en tant que mécanisme de retour d'information pour le contenu et nous les remplacerons par un nouveau système de retour d'information. Pour plus d’informations, voir:Soumettre et afficher des commentaires pour