Gérer des groupes de ressources Azure avec l’API de fonction TypeScript

Article
03/30/2023

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.

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
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 sur production.

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 un list 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

Capture d’écran partielle de l’Explorateur Azure de Visual Studio Code montrant les paramètres de l’application de fonction distante/cloud.

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 appet 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 Kustotraces 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

GitHub : Azure-Samples/azure-typescript-e2e-apps

Étapes suivantes

Convertir du texte en parole dans Express.js application

Gérer des groupes de ressources Azure avec l’API de fonction TypeScript

Créer ou utiliser un abonnement Azure existant

Prérequis

Architecture de l'application

1. Préparation de votre environnement

Obtenir votre ID d’abonnement Azure

Créer un principal du service Azure

2. Créer une application de fonction Azure locale dans Visual Studio Code

Créer une application de fonction

Ajouter des paramètres de principal de service au fichier local.settings.json

Installer les dépendances npm pour la gestion des identités et des ressources Azure

Lister tous les groupes de ressources dans un abonnement avec JavaScript

Tester les fonctions locales

Dépannage

3. Créer une application de fonction Azure basée sur le cloud

4. Configurer l’application de fonction Azure basée sur le cloud

5. Déployer l’application de fonction Resource Manager

Utiliser l’extension Visual Studio Code pour le déploiement sur l’environnement d’hébergement

Vérifier que l’application Functions est disponible avec un navigateur

6. Ajouter des API à l’application de fonction et redéployer dans Azure

Créer une API resourcegroup pour votre application de fonction

Créer une API de ressources pour votre application de fonction

Démarrer votre application de fonction locale et tester la nouvelle API

Redéployer votre application de fonction avec les nouvelles API sur Azure

Vérifier les API de fonction avec le navigateur

7. Afficher et interroger les journaux de votre application de fonction

Interroger vos journaux de fonctions Azure

8. Nettoyer les ressources Azure

Supprimer le groupe de ressources

Supprimer le principal de service

Exemple de code

Étapes suivantes

Commentaires

Commentaires

Ressources supplémentaires

Gérer des groupes de ressources Azure avec l’API de fonction TypeScript

Créer ou utiliser un abonnement Azure existant

Prérequis

Architecture de l'application

1. Préparation de votre environnement

Connectez-vous à Azure CLI

Obtenir votre ID d’abonnement Azure

Créer un principal du service Azure

2. Créer une application de fonction Azure locale dans Visual Studio Code

Créer une application de fonction

Ajouter des paramètres de principal de service au fichier local.settings.json

Installer les dépendances npm pour la gestion des identités et des ressources Azure

Lister tous les groupes de ressources dans un abonnement avec JavaScript

Tester les fonctions locales

Dépannage

3. Créer une application de fonction Azure basée sur le cloud

4. Configurer l’application de fonction Azure basée sur le cloud

5. Déployer l’application de fonction Resource Manager

Utiliser l’extension Visual Studio Code pour le déploiement sur l’environnement d’hébergement

Vérifier que l’application Functions est disponible avec un navigateur

6. Ajouter des API à l’application de fonction et redéployer dans Azure

Créer une API resourcegroup pour votre application de fonction

Créer une API de ressources pour votre application de fonction

Démarrer votre application de fonction locale et tester la nouvelle API

Redéployer votre application de fonction avec les nouvelles API sur Azure

Vérifier les API de fonction avec le navigateur

7. Afficher et interroger les journaux de votre application de fonction

Interroger vos journaux de fonctions Azure

8. Nettoyer les ressources Azure

Supprimer le groupe de ressources

Supprimer le principal de service

Exemple de code

Étapes suivantes

Commentaires

Commentaires

Ressources supplémentaires