API TypeScript serverless : stocker des données dans MongoDB avec Azure Functions

  • Article

Créez une API de fonction Azure pour stocker des données avec l’API Mongoose dans Azure Cosmos DB, puis déployez l’application de fonction dans le cloud Azure pour l’hébergement avec un point de terminaison HTTP public.

Remarque

Cet article utilise le modèle de programmation Azure Functions Node.js v4 actuellement en préversion.

Flow chart showing path of HTTP request to pass data through Azure Functions and store in Azure Cosmos DB.

Préparer votre environnement de développement

Installez les logiciels suivants :

1. Se connecter à Azure dans Visual Studio Code

Si vous utilisez déjà les extensions de service Azure, vous devez être connecté et pouvez ignorer cette étape.

Une fois que vous avez installé une extension de service Azure dans Visual Studio Code, vous devez vous connecter à votre compte Azure.

  1. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).

  2. Dans la section Ressources , sélectionnez Se connecter à Azure, puis suivez les invites.

    Sign in to Azure through VS Code

  3. Une fois connecté, vérifiez que l’adresse e-mail de votre compte Azure s’affiche dans la barre d’état et que vos abonnements apparaissent dans l’explorateur Azure :

    VS Code Azure explorer showing subscriptions

2. Créer un groupe de ressources Azure

Un groupe de ressources est une collection de ressources basée sur une région. Quand vous créez un groupe de ressources, puis des ressources dans ce groupe, à la fin du tutoriel, vous pouvez supprimer le groupe de ressources sans avoir à supprimer chaque ressource individuellement.

  1. Créez un dossier sur votre système local à utiliser comme racine du projet Azure Functions.

  2. Ouvrez ce dossier dans Visual Studio Code.

  3. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).

  4. Recherchez votre abonnement sous Ressources, puis sélectionnez l’icône + Créer un groupe de ressources.

  5. Utilisez le tableau suivant pour répondre aux invites :

    Prompt Valeur
    Entrer le nom du nouveau groupe de ressources azure-tutorial
    Sélectionnez un emplacement pour vos nouvelles ressources. Sélectionnez une région géographique proche de vous.

3. Créer l’application Functions locale

Créez une application Azure Functions locale (serverless) qui contient une fonction de Déclencheur HTTP.

  1. Dans Visual Studio Code, ouvrez la palette de commandes (Ctrl + Maj + P).

  2. Recherchez et sélectionnez Azure Functions : Créer un projet .

  3. Utilisez le tableau suivant pour terminer la création du projet de fonction Azure local :

    Prompt Valeur Notes
    Sélectionnez le dossier qui contiendra votre projet de fonction Sélectionnez le dossier actuel (par défaut).
    Sélectionner une langue TypeScript
    Sélectionner un modèle de programmation TypeScript Modèle V4 (préversion)
    Sélectionner un modèle pour la première fonction de votre projet Déclencheur HTTP L’API est appelée avec une requête HTTP.
    Fournir un nom de fonction blogposts La route de l’API est /api/blogposts

  4. Lorsque Visual Studio Code crée le projet, affichez votre code d’API dans le ./src/functions/blogposts.ts fichier.

    import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

export async function blogposts(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function processed request for url "${request.url}"`);

    const name = request.query.get('name') || await request.text() || 'world';

    return { body: `Hello, ${name}!` };
};

app.http('blogposts', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    handler: blogposts
});

    Ce code est réutilisable standard dans le nouveau modèle de programmation v4. Il n’est pas destiné à indiquer la seule façon d’écrire une couche API avec POST et GET.

  5. Remplacez le code précédent par le code suivant pour autoriser uniquement les requêtes GET à retourner tous les billets de blog.

    import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";

// curl --location 'http://localhost:7071/api/blogposts' --verbose
export async function getBlogPosts(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function getBlogPosts processed request for url "${request.url}"`);

    // Empty array for now ... will fix later
    const blogposts = [];

    return {
        status: 200,
        jsonBody: {
            blogposts
        }
    };
};

app.get('getBlogPosts', {
    route: "blogposts",
    authLevel: 'anonymous',
    handler: getBlogPosts
});

    Plusieurs modifications de modèle de programmation Azure Functions Node.js v4 sont apportées à ce code que vous devez noter :

    • Le nom de getBlobPostsla fonction , indiquant qu’il s’agit d’une requête GET, vous aidera à isoler la fonction dans les journaux.
    • La route propriété est définie sur blogposts, qui fait partie de l’itinéraire d’API par défaut fourni, /api/blogposts.
    • La methods propriété a été supprimée et n’est pas nécessaire, car l’utilisation de get l’objet app indique qu’il s’agit d’une requête GET. Les fonctions de méthode sont répertoriées ci-dessous. Si vous avez une autre méthode, vous pouvez revenir à l’aide de la methods propriété.
      • deleteRequest()
      • get()
      • patch()
      • post()
      • put()

4. Démarrer l’émulateur de stockage local Azurite

Le développement de fonctions sur votre ordinateur local nécessite un émulateur Stockage (gratuit) ou un compte Stockage Azure (payant).

Dans un terminal distinct, démarrez l’émulateur de stockage local Azurite .

azurite --silent --location ./azurite --debug ./azurite/debug.log

Cela est nécessaire pour exécuter Azure Functions localement à l’aide d’un émulateur de Stockage Azure local. L’émulateur de stockage local est spécifié dans le local.settings.json fichier avec la propriété AzureWebJobs Stockage avec la valeur UseDevelopmentStorage=true.

{
    "IsEncrypted": false,
    "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing"
    }
}

Le azurite sous-dossier a déjà été ajouté à votre .gitignore fichier.

5. Exécuter la fonction serverless locale

Exécutez le projet Azure Functions localement pour le tester avant de le déployer sur Azure.

  1. Dans Visual Studio Code, définissez un point d’arrêt sur l’instruction return , à la fin de la fonction getBlogPosts .

  2. Dans Visual Studio Code, appuyez sur F5 pour lancer le débogueur et l’attacher à l’hôte Azure Functions.

    Vous pouvez également utiliser la commande de menu Déboguer>Démarrer le débogage.

  3. La sortie s’affiche dans le panneau Terminal .

  4. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).

  5. Dans la section Espace de travail , recherchez et développez le projet local ->Functions ->getBlogPosts.

  6. Cliquez avec le bouton droit sur le nom de la fonction, getBlogPosts, puis sélectionnez Copier l’URL de la fonction.

    Partial screenshot of Visual Studio Code, with the Azure Function's button named Copy Function URL highlighted.

  7. Dans votre navigateur, collez l’URL et sélectionnez Entrée ou utilisez la commande cURL suivante dans le terminal :

    curl http://localhost:7071/api/blogposts --verbose

    La réponse d’un tableau vide de billets de blog est retournée comme suit :

    *   Trying 127.0.0.1:7071...
* Connected to localhost (127.0.0.1) port 7071 (#0)
> GET /api/blogposts HTTP/1.1
> Host: localhost:7071
> User-Agent: curl/7.88.1
> Accept: */*
>
< HTTP/1.1 200 OK
< Content-Type: application/json
< Date: Mon, 08 May 2023 17:35:24 GMT
< Server: Kestrel
< Transfer-Encoding: chunked
<
{"blogposts":[]}* Connection #0 to host localhost left intact

  8. Dans VS Code, arrêtez le débogueur, Maj + F5.

6. Créer l’application de fonction Azure dans Visual Studio Code

Dans cette section, vous allez créer une ressource cloud d’application de fonction et des ressources associées dans votre abonnement Azure.

  1. Dans Visual Studio Code, ouvrez la palette de commandes (Ctrl + Maj + P).

  2. Recherchez et sélectionnez Azure Functions : Créer une application de fonction dans Azure (avancé).

  3. Quand vous y êtes invité, indiquez les informations suivantes :

    Prompt Sélection
    Entrer un nom global unique pour l’application de fonction Tapez un nom valide dans un chemin d’URL, par first-functionexemple . Postpend 3 caractères pour rendre l’URL globalement unique. Le système vérifie que le nom que vous tapez est unique dans Azure Functions.
    Sélectionner une pile d’exécution Choisissez Node.js 18 LTS ou une version plus récente.
    Sélectionner un système d’exploitation Choisissez Linux.
    Sélectionner un groupe de ressources pour les nouvelles ressources Créez un groupe de ressources nommé azure-tutorial-first-function. Ce groupe de ressources aura finalement plusieurs ressources : Azure Function, Stockage Azure et l’API Cosmos DB pour MongoDB.
    Sélectionner un plan d’hébergement Choisissez Consommation.
    Sélectionner un compte de stockage Sélectionnez Créer un compte de stockage et acceptez le nom par défaut.
    Sélectionnez une ressource Application Insights pour votre application. Sélectionnez Créer une ressource application Recommandations et acceptez le nom par défaut.

    Attendez que la notification confirme que l’application a été créée.

7. Déployer l’application de fonction Azure sur Azure dans Visual Studio Code

Important

Le déploiement vers une application de fonction existante remplace toujours le contenu de cette application dans Azure.

  1. Sélectionnez l’icône Azure dans la barre d’activité, puis, dans la zone Ressources, cliquez avec le bouton droit sur votre ressource d’application de fonction, puis sélectionnez l’application déployer sur fonction.
  2. Si vous êtes invité à déployer, sélectionnez Déployer.
  3. Une fois le déploiement terminé, une notification s’affiche avec plusieurs options. Sélectionnez Afficher la sortie pour afficher les résultats. Si vous manquez la notification, sélectionnez l’icône de cloche dans le coin inférieur droit pour la voir de nouveau.

8. Ajouter le paramètre d’application à l’application cloud

  1. Sélectionnez l’icône Azure dans la barre d’activité, puis, dans la zone Ressources, développez votre ressource d’application de fonction, puis cliquez avec le bouton droit sur Application Paramètres.

  2. Sélectionnez Ajouter un nouveau paramètre et ajoutez le paramètre suivant pour activer le modèle de programmation Node.js v4 (préversion).

    Paramètre Valeur
    AzureWebJobsFeatureFlags EnableWorkerIndexing

9. Exécuter la fonction serverless distante

  1. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).

  2. Dans la section Ressources , développez votre ressource d’application De fonction Azure. Cliquez avec le bouton droit sur le nom de la fonction et sélectionnez Copier l’URL de la fonction.

  3. Collez l’URL dans un navigateur. Le même tableau vide est retourné que lorsque vous avez exécuté la fonction localement.

    {"blogposts":[]}

10. Ajouter l’intégration de l’API Azure Cosmos DB pour MongoDB

Azure Cosmos DB fournit une API MongoDB pour fournir un point d’intégration familier.

  1. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).

  2. Dans la section Ressources , sélectionnez + ensuite Créer un serveur de base de données. Utilisez le tableau suivant pour répondre aux invites de création d’une ressource Azure Cosmos DB.

    Prompt Valeur Notes
    Sélectionner un serveur de base de données Azure Azure Cosmos DB pour l’API MongoDB
    Fournissez un nom de compte Azure Cosmos DB. cosmosdb-mongodb-database Postpend trois caractères pour créer un nom unique. Le nom est intégré à l’URL de l’API.
    Sélectionner un modèle de capacité Sans serveur
    Sélectionnez un groupe de ressources pour les nouvelles ressources. azure-tutorial-first-function Sélectionnez le groupe de ressources que vous avez créé dans une section précédente.
    Sélectionnez un emplacement pour les nouvelles ressources. Sélectionnez la région recommandée.

11. Installer la dépendance mongoose

Dans un terminal Visual Studio Code, Ctrl + Maj + `, puis installez le package npm :

npm install mongoose

12. Ajouter du code mongoose pour les billets de blog

  1. Dans Visual Studio Code, créez un sous-répertoire nommé lib sur ./src/, créez un fichier nommé ./database.ts et copiez le code suivant dans celui-ci.

    import { Schema, Document, createConnection, ConnectOptions, model, set } from 'mongoose';

const connectionString = process.env.MONGODB_URI;
console.log('connectionString', connectionString);

const connection = createConnection(connectionString, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  autoIndex: true
} as ConnectOptions);

export interface IBlogPost {
  author: string
  title: string
  body: string
}

export interface IBlogPostDocument extends IBlogPost, Document {
  id: string
  created: Date
}

const BlogPostSchema = new Schema({
  id: Schema.Types.ObjectId,
  author: String,
  title: String,
  body: String,
  created: {
    type: Date,
    default: Date.now
  }
});

BlogPostSchema.set('toJSON', {
  transform: function (doc, ret, options) {
      ret.id = ret._id;
      delete ret._id;
      delete ret.__v;
  }
}); 

export const BlogPost = model<IBlogPostDocument>('BlogPost', BlogPostSchema);

connection.model('BlogPost', BlogPostSchema);

export default connection;

  2. Dans Visual Studio Code, ouvrez le fichier ./src/functions/blogposts et remplacez le code de tout le fichier par :

    import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
import connection from '../lib/database';

// curl --location 'http://localhost:7071/api/blogposts' --verbose
export async function getBlogPosts(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function getBlogPosts processed request for url "${request.url}"`);

    const blogposts = await connection.model('BlogPost').find({});

    return {
        status: 200,
        jsonBody: {
            blogposts
        }
    };
};

app.get('getBlogPosts', {
    route: "blogposts",
    authLevel: 'anonymous',
    handler: getBlogPosts
});

13. Ajouter chaîne de connexion à l’application locale

  1. Dans l’Explorateur Azure de Visual Studio Code, sélectionnez la section Azure Cosmos DB et développez pour cliquer avec le bouton droit sur sélectionner votre nouvelle ressource.

  2. Sélectionnez Copier chaîne de connexion.

  3. Dans Visual Studio Code, utilisez l’Explorateur de fichiers pour ouvrir ./local.settings.json.

  4. Ajoutez une nouvelle propriété appelée MONGODB_URI et collez la valeur de votre chaîne de connexion.

    {
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "",
    "FUNCTIONS_WORKER_RUNTIME": "node",
    "AzureWebJobsFeatureFlags": "EnableWorkerIndexing",
    "MONGODB_URI": "mongodb://...."
  }
}

    Secrets dans le ./local.settings.json fichier :

    • N’est pas déployé sur Azure, car il est inclus dans le ./.funcignore fichier.
    • N’est pas case activée dans le contrôle de code source, car il est inclus dans le ./.gitignore fichier.

  5. Exécutez l’application localement et testez l’API avec la même URL dans la section précédente.

14. Ajouter chaîne de connexion à l’application distante

  1. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).
  2. Dans la section Ressources , recherchez votre instance Azure Cosmos DB. Cliquez avec le bouton droit sur la ressource et sélectionnez Copier Connecter ion String.
  3. Dans la même section Ressources , recherchez votre application de fonction et développez le nœud.
  4. Cliquez avec le bouton droit sur Paramètres d’application et sélectionnez Ajouter un nouveau paramètre.
  5. Entrez le nom du paramètre d’application, MONGODB_URI puis sélectionnez Entrée.
  6. Collez la valeur que vous avez copiée et appuyez sur Entrée.

15. Ajouter des API pour créer, mettre à jour et supprimer des billets de blog

  1. Dans Visual Studio Code, utilisez la palette de commandes pour rechercher et sélectionner Azure Functions : Créer une fonction.

  2. Sélectionnez le déclencheur HTTP et nommez-le blogpost (singulier).

  3. Copiez le code suivant dans le fichier.

    import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
import connection, { IBlogPost, IBlogPostDocument }  from '../lib/database';

// curl -X POST --location 'http://localhost:7071/api/blogpost' --header 'Content-Type: application/json' --data '{"author":"john","title":"my first post", "body":"learn serverless node.js"}' --verbose
export async function addBlogPost(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function addBlogPost processed request for url "${request.url}"`);

    const body = await request.json() as IBlogPost;

    const blogPostResult = await connection.model('BlogPost').create({
        author: body?.author,
        title: body?.title,
        body: body?.body
    });

    return {
        status: 200,
        jsonBody: {
            blogPostResult
        }
    };
};

// curl -X PUT --location 'http://localhost:7071/api/blogpost/64568e727f7d11e09eab473c' --header 'Content-Type: application/json' --data '{"author":"john jones","title":"my first serverless post", "body":"Learn serverless Node.js with Azure Functions"}' --verbose
export async function updateBlogPost(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function updateBlogPost processed request for url "${request.url}"`);

    const body = await request.json() as IBlogPost;
    const id = request.params.id;

    const blogPostResult = await connection.model('BlogPost').updateOne({ _id: id }, {
        author: body?.author,
        title: body?.title,
        body: body?.body
    });

    if(blogPostResult.matchedCount === 0) {
        return {
            status: 404,
            jsonBody: {
                message: 'Blog post not found'
            }
        };
    }

    return {
        status: 200,
        jsonBody: {
            blogPostResult
        }
    };
};

// curl --location 'http://localhost:7071/api/blogpost/6456597918547e37d515bda3' --verbose
export async function getBlogPost(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function getBlogPosts processed request for url "${request.url}"`);

    console.log('request.params.id', request.params.id)
    const id = request.params.id;

    const blogPost = await connection.model('BlogPost').findOne({ _id: id });

    if(!blogPost) {
        return {
            status: 404,
            jsonBody: {
                message: 'Blog post not found'
            }
        };
    }

    return {
        status: 200,
        jsonBody: {
            blogPost
        }
    };
};

// curl --location 'http://localhost:7071/api/blogpost/6456597918547e37d515bda3' --request DELETE --header 'Content-Type: application/json' --verbose
export async function deleteBlogPost(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log(`Http function deleteBlogPost processed request for url "${request.url}"`);

    const id = request.params.id;

    const blogPostResult = await connection.model('BlogPost').deleteOne({ _id: id });

    if(blogPostResult.deletedCount === 0) {
        return {
            status: 404,
            jsonBody: {
                message: 'Blog post not found'
            }
        };
    }

    return {
        status: 200,
        jsonBody: {
            blogPostResult
        }
    };
};

app.get('getBlogPost', {
    route: "blogpost/{id}",
    authLevel: 'anonymous',
    handler: getBlogPost
});

app.post('postBlogPost', {
    route: "blogpost",
    authLevel: 'anonymous',
    handler: addBlogPost
});

app.put('putBlogPost', {
    route: "blogpost/{id}",
    authLevel: 'anonymous',
    handler: updateBlogPost
});

app.deleteRequest('deleteBlogPost', {
    route: "blogpost/{id}",
    authLevel: 'anonymous',
    handler: deleteBlogPost
});

  4. Démarrez à nouveau la fonction locale avec le débogueur. Les API suivantes sont disponibles :

    deleteBlogPost: [DELETE] http://localhost:7071/api/blogpost/{id}
getBlogPost: [GET] http://localhost:7071/api/blogpost/{id}
getBlogPosts: [GET] http://localhost:7071/api/blogposts
postBlogPost: [POST] http://localhost:7071/api/blogpost
putBlogPost: [PUT] http://localhost:7071/api/blogpost/{id}

  5. Utilisez l’API blogpost (singular) à partir d’une commande cURL pour ajouter quelques billets de blog.

    curl -X POST --location 'http://localhost:7071/api/blogpost' --header 'Content-Type: application/json' --data '{"author":"john","title":"my first post", "body":"learn serverless node.js"}' --verbose

  6. Utilisez l’API blogposts (plural) à partir d’une commande cURL pour obtenir les billets de blog.

    curl http://localhost:7071/api/blogposts --verbose

16. Afficher toutes les données avec l’extension Visual Studio Code pour Azure Cosmos DB

  1. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).

  2. Dans la section Ressources, cliquez avec le bouton droit sur votre base de données Azure Cosmos DB, puis sélectionnez Actualiser.

  3. Développez la base de données de test et le nœud de collection blogposts pour afficher les documents.

  4. Sélectionnez l’un des éléments répertoriés pour afficher les données dans l’instance Azure Cosmos DB.

    Partial screenshot of Visual Studio Code, showing the Azure explorer with the Databases with a selected item displayed in the reading pane.

17. Redéployer l’application de fonction pour inclure du code de base de données

  1. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).
  2. Dans la section Ressources, cliquez avec le bouton droit sur votre application de fonction Azure, puis sélectionnez Déployer sur l’application de fonction.
  3. Dans la fenêtre contextuelle vous demandant si vous souhaitez déployer, sélectionnez Déployer.
  4. Attendez la fin du déploiement avant de continuer.

18. Utiliser la fonction Azure basée sur le cloud

  1. Toujours dans l’Explorateur Azure, dans la zone Functions, sélectionne et développe votre fonction, puis le nœud Functions , qui répertorie les API
  2. Cliquez avec le bouton droit sur l’une des API et sélectionnez Copier l’URL de la fonction.
  3. Modifiez les commandes cURL précédentes pour utiliser la URL distante au lieu de l’URL locale. Exécutez les commandes pour tester l’API distante.

19. Interroger vos journaux de fonction Azure

Pour effectuer une recherche dans les journaux, utilisez le portail Azure.

  1. Dans Visual Studio Code, sélectionnez l’Explorateur Azure, puis, sous Functions, 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.

  2. Dans Paramètres, sélectionnez Application Recommandations, puis affichez les données d’application Recommandations.

    Browser screenshot showing menu choices. Select **Application Insights** from the Settings, then select **View Application Insights data**.

    Ce lien vous permet d’accéder à la ressource de métriques qui a été créée en même temps que votre fonction Azure avec Visual Studio Code.

  3. Dans la section Surveillance , sélectionnez Journaux. 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.

  4. Dans le volet Nouvelle requête 1, 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.

  5. Modifiez la requête pour rechercher les journaux personnalisés :

    traces 
| where message startswith "***"

  6. 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.

    Vous n’avez rien à faire de plus pour accéder à ces informations de journalisation :

    • Le code a utilisé la context.log fonction fournie par l’infrastructure de fonction. En utilisant context, au lieu de console, votre journalisation peut être filtrée sur la fonction individuelle spécifique. Cela est utile si votre application de fonction a de nombreuses fonctions.
    • L’application de fonction a ajouté Application Insights pour vous.
    • L’outil Requête Kusto est inclus dans la 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é.

20. Nettoyer les ressources

Étant donné que vous avez utilisé un seul groupe de ressources, vous pouvez supprimer toutes les ressources en supprimant le groupe de ressources.

  1. Dans Visual Studio Code, ouvrez l’Explorateur Azure en sélectionnant l’icône Azure dans la barre latérale principale ou utilisez le raccourci clavier (Maj Alt + + A).
  2. Recherchez et sélectionnez Azure : Regrouper par groupe de ressources.
  3. Cliquez avec le bouton droit sur votre groupe de ressources, puis sélectionnez Supprimer le groupe de ressources.
  4. Entrez le nom du groupe de ressources pour confirmer la suppression.

Code source disponible

Code source complet pour cette application de fonction Azure :

Étapes suivantes

Créer une fonction Azure pour gérer des ressources Azure