Gérer les groupes de ressources Azure avec l’API TypeScript Function

Article
08/22/2024

Dans ce tutoriel, vous allez créer une application TypeScript Azure Function locale avec des API pour gérer des groupes de ressources Azure et déployer l’application sur Azure.

Fonctionnalités :

Créer un projet d’application TypeScript Azure Function local dans Visual Studio Code
Créer du code réutilisable d’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 locaux et distants avec Visual Studio Code
Utiliser DefaultAzureCredential dans des 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

Avertissement

Ce tutoriel est destiné à être adopté rapidement et, par conséquent, il ne respecte pas les exigences de sécurité par défaut. Pour en savoir plus sur ce scénario avec un objectif de sécurité par défaut, consultez les considérations relatives à la sécurité.

Comme le code source est écrit avec TypeScript, il est simple. Si vous connaissez bien le JavaScript moderne avec async/await, le code vous sera familier.

Prérequis

Un compte d’utilisateur et un abonnement Azure : créez un abonnement gratuit.
Node.js LTS LTS installé 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.
- L'extension Azure Function v1.10.4 ou ultérieure doit être installée.
Azure Functions Core Tools v4.0.5095 ou ultérieure doit être installé.
Azure Cloud Shell ou Azure CLI doivent être installés sur votre ordinateur local.

Architecture de l'application

L’application fournit les points de terminaison d’API suivants.

Method	URL	Description
POST,DELETE	http://localhost:7071/api/resourcegroup	Ajouter ou supprimer 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.

Comme ces points de terminaison sont publics, vous devez sécuriser vos points de terminaison d’API avec l’authentification et l’autorisation avant le déploiement dans votre environnement.

Cette application est limitée à un abonnement, car il s’agit du nombre spécifié 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 à l’aide de 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, il est préférable d'avoir des principes de service distincts pour chaque environnement.

Déterminez un format de nom de principal de service afin de trouver facilement votre principal de service ultérieurement. 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
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 Azure Function 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.

Saisissez Azure Functions: create new project. Utilisez le tableau suivant pour terminer les invites :

Prompt	Valeur
Sélectionner le dossier où placer votre projet de fonction	Sélectionner le répertoire par défaut (emplacement actif)
Sélectionner une langue	Sélectionnez TypeScript.
Sélectionner un modèle de programmation TypeScript	Sélectionnez Model 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 ce projet après cet article, remplacez le niveau d’autorisation par la fonction. En savoir plus sur l’autorisation de niveau fonction.

Le code réutilisable du projet est créé et les dépendances sont installées.

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

Ouvrez le fichier ./local.settings.json dans le répertoire racine du projet et ajoutez votre section VALEURS 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 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 vers /api/resourcegroups et renvoie 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 nouveau fichier dans le 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 nommé environment-vars.ts dans le répertoire ./src/lib 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 nommé error.ts dans le répertoire ./src/lib 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 variable NODE_ENV 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 + Shift + 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 le subscriptionId et une 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 cloud Azure Function

Dans Visual Studio Code, sélectionnez l’icône Azure pour ouvrir Azure Explorer.
Sélectionnez l’icône + pour créer une nouvelle application Azure Function dans le cloud Azure.
Sélectionnez Créer une application de fonction dans Azure.
Entrez un nom globalement unique pour la nouvelle application de fonction. Le nom doit être unique pour 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 consultez le journal d’activité Azure pour plus d’informations.

4. Configurer l'application cloud Azure Function

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 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 une application de fonction Resource Manager

Déployez une application Azure Function 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 fichier local.settings.json afin qu’il soit visible. Cela facilitera la copie des noms et des valeurs.
Sélectionnez le logo Azure pour ouvrir Azure Explorer, puis sous Fonctions, sélectionnez l'icône du 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éée dans la section précédente.
Quand il vous est demandé si vous voulez 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 auprès de l’API cloud.

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

Ajoutez les API suivantes, puis redéployez votre application Azure Function dans Visual Studio Code :

Ajouter et supprimer des groupes de ressources
Répertorier les ressources d’un groupe de ressources ou d’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 afin de créer et de 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 continuez ce projet, remplacez le niveau d’autorisation par la fonction. En savoir plus sur l’autorisation de niveau fonction.

Ouvrez le fichier ./src/functions/resourcegroup.ts et remplacez le entièrement 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 fichier ./src/lib/azure-resource-groups.ts contient déjà le code permettant d’ajouter et de supprimer des groupes de ressources.

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

Utilisez l’extension Visual Studio Code pour Azure Functions pour ajouter les fichiers TypeScript à votre application de fonction afin de 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 continuez ce projet, remplacez le niveau d’autorisation par la fonction. En savoir plus sur l’autorisation de niveau fonction.

Ouvrez le fichier ./src/functions/resources.ts et remplacez-le entièrement 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 fichier ./src/lib/azure-resource.ts 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 afin d’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 + Shift + p pour entrer dans deploy to function app, puis exécutez 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 Azure Function, par exemple https://myfunction.azurewebsites.net.

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

Affichez et interrogez les journaux des applications Azure Function 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û à un délai de quelques minutes entre la requête HTTP adressée à la fonction Azure et la disponibilité des journaux dans Kusto. Patientez quelques minutes avant de réexécuter la requête.

Étant donné qu'une ressource Application Insights a été ajoutée quand vous avez créé l’application Azure Function, vous n’avez rien eu à faire de plus pour récupérer 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’apprendre à écrire une requête Kusto pour obtenir ne serait-ce que le minimum d’informations de vos journaux.

8. Nettoyer des ressources Azure

Supprimer le groupe de ressources

Dans VS Code, sélectionnez le logo Azure pour ouvrir Azure Explorer, puis dans 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.
Dans la section Vue d’ensemble, recherchez et sélectionnez le nom du groupe de ressources. Vous accédez alors au groupe de ressources dans le portail Azure.
La page du groupe de ressources répertorie toutes les ressources associées à ce tutoriel.
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

Exécutez la commande suivante pour supprimer le principal de service. 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

Considérations de sécurité

En tant que tutoriel pour débutant, cette solution ne présente pas les pratiques de sécurité par défaut. Il s'agit d'une démarche intentionnelle pour vous permettre de réussir à déployer la solution. Une fois le déploiement réussi, l’étape suivante consiste à sécuriser les ressources. Cette solution utilise trois services Azure, chacun ayant ses propres fonctionnalités de sécurité et considérations relatives à la configuration sécurisée par défaut :

Azure Functions - Sécurisation d’Azure Functions
Azure Storage - Recommandations de sécurité pour le stockage Blob

Étapes suivantes

Convertir du texte en paroles avec l'application Express.js

Partager via

Gérer les groupes de ressources Azure avec l’API TypeScript Function

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 cloud Azure Function

4. Configurer l'application cloud Azure Function

5. Déployer une 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 sur Azure

Créer une API resourcegroup pour votre application de fonction

Créer une API des 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 des ressources Azure

Supprimer le groupe de ressources

Supprimer le principal de service

Exemple de code

Considérations de sécurité

Étapes suivantes

Commentaires

Ressources supplémentaires

Partager via

Gérer les groupes de ressources Azure avec l’API TypeScript Function

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 cloud Azure Function

4. Configurer l'application cloud Azure Function

5. Déployer une 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 sur Azure

Créer une API resourcegroup pour votre application de fonction

Créer une API des 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 des ressources Azure

Supprimer le groupe de ressources

Supprimer le principal de service

Exemple de code

Considérations de sécurité

Étapes suivantes

Commentaires

Ressources supplémentaires