Diffusez les requêtes HTTP et les réponses dans Node.js Azure Functions

Cet article décrit comment diffuser les requêtes et réponses HTTP dans votre application Node.js fonction. Apprenez à activer le streaming, à traiter de grosses données et à gérer des scénarios HTTP en temps réel.

Note

Les flux HTTP nécessitent le modèle de programmation v4. Si vous utilisez la v3, consultez le guide de migration pour mettre à jour.

Overview

La fonctionnalité HTTP streams facilite le traitement de grosses données en streaming, la diffusion des réponses OpenAI, la diffusion de contenus dynamiques et la prise en charge d’autres scénarios HTTP clés. Cela vous permet de diffuser en continu des requêtes vers et des réponses à partir de points de terminaison HTTP dans votre application de fonction Node.js. Utilisez des flux HTTP dans des scénarios où votre application nécessite un échange et une interaction en temps réel entre le client et le serveur via HTTP. Vous pouvez également utiliser des flux HTTP pour obtenir les meilleures performances et la fiabilité optimale pour vos applications lors de l’utilisation de HTTP.

Prerequisites

Activer les flux

Procédez comme suit pour activer les flux HTTP dans votre application de fonction dans Azure et dans vos projets locaux :

  1. Si vous envisagez de diffuser en continu de grandes quantités de données, modifiez le paramètre FUNCTIONS_REQUEST_BODY_SIZE_LIMIT dans Azure. La taille maximale par défaut autorisée est 104857600, ce qui limite vos requêtes à environ 100 Mo.

  2. Pour le développement local, ajoutez également FUNCTIONS_REQUEST_BODY_SIZE_LIMIT au fichier local.settings.json.

  3. Ajoutez le code suivant à votre application dans n’importe quel fichier inclus par votre champ principal.

const { app } = require("@azure/functions");

app.setup({ enableHttpStream: true });

Tip

Utilisez request.body directement pour tirer le meilleur parti du streaming. Des méthodes comme request.text() mettent en mémoire tampon l’intégralité du corps et renvoient une chaîne, ce qui va à l’encontre de l’objectif du streaming.

Exemples de flux

L’exemple suivant montre une fonction déclenchée par HTTP qui reçoit des données via une requête HTTP POST. La fonction transmet ces données vers un fichier de sortie spécifié :

const { app } = require("@azure/functions");
const fs = require("fs");
const path = require("path");

app.http("httpTriggerStreamRequest", {
  methods: ["POST"],
  handler: async (request, context) => {
    context.log("HTTP trigger function processed a request.");

    if (!request.body) {
      return {
        status: 400,
        body: "Request body is required"
      };
    }

    // Create a writable stream to a file
    const outputPath = path.join(__dirname, "streamed-output.txt");
    const writeStream = fs.createWriteStream(outputPath);

    try {
      // Stream the request body to the file
      const reader = request.body.getReader();
      let done = false;

      while (!done) {
        const { value, done: readerDone } = await reader.read();
        done = readerDone;
        
        if (value) {
          writeStream.write(value);
        }
      }

      writeStream.end();
      
      return {
        status: 200,
        body: "Data successfully streamed to file"
      };
    } catch (error) {
      context.log.error("Error streaming data:", error);
      return {
        status: 500,
        body: "Error processing stream"
      };
    }
  }
});

L’exemple suivant montre une fonction déclenchée par HTTP qui diffuse le contenu d’un fichier en réponse aux requêtes HTTP GET entrantes :

const { app } = require("@azure/functions");
const fs = require("fs");
const path = require("path");

app.http("httpTriggerStreamResponse", {
  methods: ["GET"],
  handler: async (request, context) => {
    context.log("HTTP trigger function processed a request.");

    const filePath = path.join(__dirname, "sample-data.txt");

    try {
      // Check if file exists
      if (!fs.existsSync(filePath)) {
        return {
          status: 404,
          body: "File not found"
        };
      }

      // Create a readable stream from the file
      const readStream = fs.createReadStream(filePath);
      
      return {
        status: 200,
        headers: {
          "Content-Type": "text/plain",
          "Transfer-Encoding": "chunked"
        },
        body: readStream
      };
    } catch (error) {
      context.log.error("Error streaming file:", error);
      return {
        status: 500,
        body: "Error streaming file"
      };
    }
  }
});

Pour une application d’exemple prête à l’exécution qui utilise des streams, consultez cet exemple sur GitHub.

  • Last updated on