---
title: "Traitement des requêtes par lots avec API Gateway - API7.ai"
description: "Dans cet article, nous explorerons comment mettre en œuvre le traitement par lots de requêtes dans Apache APISIX et examinerons quelques cas d'utilisation où cela peut être bénéfique."
url: "https://api7.ai/fr/blog/batch-request-processing-with-api-gateway"
---

[Blog](https://api7.ai/fr/blog)

[Products](https://api7.ai/fr/category/products)[Technology](https://api7.ai/fr/category/technology)[Ecosystem](https://api7.ai/fr/category/ecosystem)[Case Study](https://api7.ai/fr/category/usercase)[Team & Community](https://api7.ai/fr/category/community)

Search

⌘ + K

[Blog](https://api7.ai/blog)

Technology

# Traitement des requêtes par lots avec API Gateway

[![Bobur Umurzokov](https://avatars.githubusercontent.com/u/14247607)](https://www.linkedin.com/in/boburumurzokov/)

[Bobur Umurzokov](https://www.linkedin.com/in/boburumurzokov/)

April 27, 2023

[Technology](https://api7.ai/category/technology)

Le *traitement par lots des requêtes* est une technique puissante utilisée dans le développement web pour améliorer les performances des API. Elle permet aux développeurs de regrouper plusieurs requêtes API en un seul cycle de requête/réponse HTTP. En d'autres termes, **une seule requête API** d'un client peut être transformée en **plusieurs requêtes API** vers un ensemble de serveurs backend, et les **réponses sont agrégées** en une seule réponse au client. Cela peut réduire considérablement le nombre d'allers-retours entre le client et le serveur.

Dans cet article, nous explorerons **comment implémenter le traitement par lots des requêtes** dans [Apache APISIX](https://apisix.apache.org/) et examinerons quelques cas d'utilisation où cela peut être bénéfique.

> Cela est similaire au modèle de [Composition d'API](https://microservices.io/patterns/data/api-composition.html) largement appliqué dans l'[architecture Microservices](https://microservices.io/patterns/microservices.html).

![Traitement par lots des requêtes vs multiples appels API](https://static.api7.ai/uploads/2024/12/25/l0d7ap0M_batch-request-processing-1.png?imageMogr2/format/webp)

## Pourquoi utiliser le traitement par lots des requêtes ?

Lorsqu'un client envoie plusieurs requêtes API à un serveur, chaque requête nécessite un cycle de requête/réponse HTTP séparé. Cela peut entraîner une latence accrue, une performance réduite et une charge serveur accrue. En regroupant plusieurs requêtes en une seule requête par lots, le nombre de cycles de requête/réponse HTTP peut être réduit, ce qui améliore les performances et réduit la latence.

Le traitement par lots des requêtes peut être particulièrement utile dans les scénarios où vous devez récupérer ou mettre à jour plusieurs enregistrements en une seule transaction, tels que :

- Récupérer plusieurs enregistrements d'une base de données
- Mettre à jour plusieurs enregistrements dans une base de données
- Exécuter plusieurs requêtes API pour accomplir une tâche

## Exemples concrets de traitement par lots des requêtes

### Exemple 1 :

Supposons que vous avez une application de médias sociaux qui affiche le fil d'actualité d'un utilisateur, comprenant des publications de ses amis et des pages qu'il suit. Pour remplir ce fil d'actualité, vous devez effectuer plusieurs requêtes API pour récupérer les données nécessaires, telles que :

- Récupérer une liste des amis de l'utilisateur et des pages qu'il suit.
- Pour chaque ami ou page, récupérer leurs publications récentes.

![Application de médias sociaux qui affiche le fil d'actualité d'un utilisateur](https://static.api7.ai/uploads/2024/12/25/8JxGaKHs_batch-request-processing-2.png?imageMogr2/format/webp)

Dans une approche traditionnelle, vous effectueriez chacune de ces requêtes API séparément. D'abord, vous récupérez une liste des amis de l'utilisateur, puis dans une deuxième requête, vous obtenez les publications récentes pour chaque ami de l'utilisateur. Cela peut entraîner une latence accrue, surtout si l'utilisateur a un grand nombre d'amis et suit de nombreuses pages.

### Exemple 2 :

Un autre exemple, vous avez une application mobile qui affiche une liste de produits que les utilisateurs peuvent parcourir. Pour remplir cette liste, vous devez effectuer plusieurs requêtes API pour récupérer les données des produits depuis un serveur distant, telles que :

- Récupérer une liste d'identifiants de produits.
- Pour chaque identifiant de produit, récupérer les détails du produit (nom, description, image, etc.)

### Exemple 3 :

Imaginez que vous avez une application web de gestion de conférences où il y a plusieurs intervenants dans le système et vous souhaitez afficher les sessions et les sujets liés d'un intervenant sur une seule page web. Un service backend [Conference API](https://conferenceapi.azurewebsites.net/) a deux points de terminaison différents `/speaker/{speakerId}/sessions` et `/speaker/{speakerId}/topics` pour exposer ces informations. Pour afficher à la fois les sessions et les sujets d'un seul intervenant, vous pouvez envoyer deux requêtes depuis l'application frontend, ce qui n'est pas une solution idéale. Au lieu de cela, vous pouvez utiliser une [API Gateway](https://apisix.apache.org/docs/apisix/terminology/api-gateway/) pour regrouper toutes ces requêtes en une seule requête HTTP, comme expliqué dans la section suivante.

![Traitement par lots des requêtes avec API Gateway](https://static.api7.ai/uploads/2024/12/25/aMr2xJjt_batch-request-processing-3.png?imageMogr2/format/webp)

## Traitement par lots des requêtes avec Apache APISIX API Gateway

Pour implémenter le traitement par lots des requêtes dans APISIX, vous pouvez utiliser le plugin [batch-requests](https://apisix.apache.org/docs/apisix/plugins/batch-requests/). Ce plugin vous permet de définir un ensemble de requêtes API dans une seule charge utile de requête `HTTP POST`. Chaque requête peut avoir sa propre méthode HTTP, chemin d'URL, ensemble d'en-têtes et charge utile. Voir ci-dessous un exemple de commande curl pour l'exemple 3 (requêtes Conference API) :

```
curl -i http://{API_GATEWAY_HOST_ADDRESS}/speaker  -X POST -d \
'{
    "pipeline": [
        {
            "method": "GET",
            "path": "/speaker/1/topics"
  },
        {
            "method": "GET",
            "path": "/speaker/1/sessions"
  }
    ]
}'
```

Lorsqu'une requête par lots est reçue par APISIX, le plugin [batch-requests](https://apisix.apache.org/docs/apisix/plugins/batch-requests/) analysera la charge utile et exécutera chaque requête du lot en parallèle. Le plugin agrègera également les réponses de chaque requête et les retournera dans une seule réponse HTTP au client. Voir la section de démonstration suivante pour apprendre comment y parvenir étape par étape.

## Démonstration du plugin batch-requests

Avant de pouvoir utiliser le plugin [batch-requests](https://apisix.apache.org/docs/apisix/plugins/batch-requests/), vous devrez installer Apache APISIX.

### Prérequis

- [Docker](https://docs.docker.com/get-docker/) est utilisé pour installer etcd et APISIX conteneurisés.
- [curl](https://curl.se/) est utilisé pour envoyer des requêtes à l'API Admin d'APISIX. Vous pouvez également utiliser des outils simples comme [Postman](https://www.postman.com/) pour interagir avec l'API.

APISIX peut être facilement installé et démarré avec le script de démarrage rapide suivant :

```
curl -sL <https://run.api7.ai/apisix/quickstart> | sh
```

### Configurer le service backend (upstream)

Vous devrez configurer le service backend pour Conference API vers lequel vous souhaitez router les requêtes. Cela peut être fait en ajoutant un serveur upstream dans Apache APISIX via l'[API Admin](https://apisix.apache.org/docs/apisix/admin-api/).

```
curl http://127.0.0.1:9180/apisix/admin/upstreams/1 -X PUT -d '
{
  "name": "Conferences API upstream",
  "desc": "Register Conferences API as the upstream",
  "type": "roundrobin",
  "scheme": "https",
  "nodes": {
    "conferenceapi.azurewebsites.net:443": 1
  }
}'
```

### Créer une Route pour l'API de traitement par lots

Nous devons créer une nouvelle route qui intercepte les requêtes vers `/speaker` et expose un point de terminaison virtuel public pour le traitement par lots en utilisant le plugin `[public-api](https://apisix.apache.org/docs/apisix/plugins/public-api/)`.

```
curl http://127.0.0.1:9180/apisix/admin/routes/a -X PUT -d '
{
    "uri": "/speaker",
    "plugins": {
        "public-api": {
      "uri": "/apisix/batch-requests"
    }
    }
}'
```

### Créer une Route pour les points de terminaison des sujets et sessions de l'intervenant

Ensuite, nous créons une autre route pour les points de terminaison des sujets et sessions de l'intervenant (`/speaker/*/topics` et `/speaker/*/sessions`) afin que les requêtes individuelles extraites par la passerelle API des requêtes par lots pour récupérer les sujets ou sessions de l'intervenant soient redirigées vers les points de terminaison responsables de Conference API et nous référençons le service upstream existant.

```
curl http://127.0.0.1:9180/apisix/admin/routes/b -X PUT -d '
{
  "methods": ["GET"],
 "uris": ["/speaker/*/topics","/speaker/*/sessions"],
    "plugins": {
      "proxy-rewrite":{
      "host":"conferenceapi.azurewebsites.net"
  }
  },
 "upstream_id":"1"
}'
```

Vous remarquerez peut-être que nous utilisons un autre plugin [proxy-rewrite](https://apisix.apache.org/docs/apisix/plugins/proxy-rewrite/) et spécifions implicitement l'adresse hôte pour Conference API. Sinon, la passerelle API peut effectuer une conversion DNS et demander Conference API par son adresse IP.

### Tester le traitement par lots des requêtes

Voici un exemple d'utilisation du plugin batch-requests dans APISIX :

```
curl -i http://127.0.0.1:9080/speaker  -X POST -d \
'{
    "pipeline": [
        {
            "method": "GET",
            "path": "/speaker/1/topics"
  },
        {
            "method": "GET",
            "path": "/speaker/1/sessions"
  }
   ]
}'
```

Dans cet exemple, la route est définie pour le point de terminaison `/speaker`, qui prend en charge le traitement par lots des requêtes via le plugin batch-requests. Le plugin est configuré avec un ensemble de deux requêtes, chacune récupérant un enregistrement d'intervenant par ID avec ses sujets et sessions. Si vous exécutez cette commande, vous obtiendrez une réponse fusionnée de la passerelle API :

```
[
   {
      "body":"{\r\n  \"collection\": {\r\n    \"version\": \"1.0\",\r\n    \"links\": [],\r\n    \"items\": [\r\n      {\r\n        \"href\": \"https://conferenceapi.azurewebsites.net/topic/8\",\r\n        \"data\": [\r\n          {\r\n            \"name\": \"Title\",\r\n            \"value\": \"Microsoft\"\r\n          }\r\n        ],\r\n        \"links\": [\r\n          {\r\n            \"rel\": \"http://tavis.net/rels/sessions\",\r\n            \"href\": \"https://conferenceapi.azurewebsites.net/topic/8/sessions\"\r\n          }\r\n        ]\r\n      },\r\n      {\r\n        \"href\": \"https://conferenceapi.azurewebsites.net/topic/10\",\r\n        \"data\": [\r\n          {\r\n            \"name\": \"Title\",\r\n            \"value\": \"Mobile\"\r\n          }\r\n        ],\r\n        \"links\": [\r\n          {\r\n            \"rel\": \"http://tavis.net/rels/sessions\",\r\n            \"href\": \"https://conferenceapi.azurewebsites.net/topic/10/sessions\"\r\n          }\r\n        ]\r\n      }\r\n    ],\r\n    \"queries\": [],\r\n    \"template\": {\r\n      \"data\": []\r\n    }\r\n  }\r\n}",
      "status":200,
      "headers":{
         "Expires":"-1",
         "Connection":"keep-alive",
         "Pragma":"no-cache",
         "Content-Length":"953",
         "Server":"APISIX/3.2.0",
         "Content-Type":"application/vnd.collection+json",
         "X-AspNet-Version":"4.0.30319",
         "Cache-Control":"no-cache",
         "X-Powered-By":"ASP.NET"
      },
      "reason":"OK"
   },
   {
      "body":"{\r\n  \"collection\": {\r\n    \"version\": \"1.0\",\r\n    \"links\": [],\r\n    \"items\": [\r\n      {\r\n        \"href\": \"https://conferenceapi.azurewebsites.net/session/206\",\r\n        \"data\": [\r\n          {\r\n            \"name\": \"Title\",\r\n            \"value\": \"\\r\\n\\t\\t\\tjQuery Mobile and ASP.NET MVC\\r\\n\\t\\t\"\r\n          },\r\n          {\r\n            \"name\": \"Timeslot\",\r\n            \"value\": \"05 December 2013 09:00 - 10:00\"\r\n          },\r\n          {\r\n            \"name\": \"Speaker\",\r\n            \"value\": \"Scott Allen\"\r\n          }\r\n        ],\r\n        \"links\": [\r\n          {\r\n            \"rel\": \"http://tavis.net/rels/speaker\",\r\n            \"href\": \"https://conferenceapi.azurewebsites.net/speaker/16\"\r\n          },\r\n          {\r\n            \"rel\": \"http://tavis.net/rels/topics\",\r\n            \"href\": \"https://conferenceapi.azurewebsites.net/session/206/topics\"\r\n          }\r\n        ]\r\n      }\r\n    ],\r\n    \"queries\": [],\r\n    \"template\": {\r\n      \"data\": []\r\n    }\r\n  }\r\n}",
      "status":200,
      "headers":{
         "Expires":"-1",
         "Connection":"keep-alive",
         "Pragma":"no-cache",
         "Content-Length":"961",
         "Server":"APISIX/3.2.0",
         "Content-Type":"application/vnd.collection+json",
         "X-AspNet-Version":"4.0.30319",
         "Cache-Control":"no-cache",
         "X-Powered-By":"ASP.NET"
      },
      "reason":"OK"
   }
]
```

> La [taille maximale](https://apisix.apache.org/docs/apisix/plugins/batch-requests/#configuration) d'une requête par lots est limitée par la passerelle API. Vous pouvez consulter la documentation de la passerelle API pour les limites actuelles et la configuration du délai d'attente des requêtes.

## Points à retenir

- Le traitement par lots des requêtes avec une passerelle API peut être une technique utile pour améliorer les performances de votre API.
- Apache APISIX fournit un plugin appelé **`batch-requests`** qui permet aux développeurs d'implémenter facilement le traitement par lots des requêtes.

## Prochaines étapes

Avec une passerelle API, il est également possible de fournir une forme d'agrégation personnalisée dans les données de réponse à vos utilisateurs. Vous pouvez utiliser le plugin [serverless-function](https://apisix.apache.org/docs/apisix/plugins/serverless/) pour exécuter du code personnalisé et fusionner la réponse des services backend et la retourner au consommateur de l'API dans une structure différente.

### Contenu recommandé

- [Pourquoi Apache APISIX est-il la meilleure passerelle API ?](https://api7.ai/blog/why-is-apache-apisix-the-best-api-gateway)
- [Qu'est-ce que les politiques de passerelle API ?](https://api7.ai/blog/api-gateway-policies)

Tags:

[API Gateway Concept](https://api7.ai/tags/api-gateway-concept)

[Request Processing](https://api7.ai/tags/request-processing)

[API Composition](https://api7.ai/tags/api-composition)

Share article link

Share

Related Posts

[![Analyse de l'instabilité de l'API DeepSeek : Ce que les API Gateways peuvent et ne peuvent pas faire](https://static.api7.ai/uploads/2025/02/11/uLte0Bp5_deepseek-api-instability.png)](https://api7.ai/blog/analyzing-deepseek-api-instability)

## [Analyse de l'instabilité de l'API DeepSeek : Ce que les API Gateways peuvent et ne peuvent pas faire](https://api7.ai/blog/analyzing-deepseek-api-instability)

[![Comment choisir la bonne API Gateway pour votre entreprise ?](https://static.api7.ai/uploads/2024/03/06/6fBCizXc_choose-right-api-gateway.png)](https://api7.ai/blog/how-to-choose-right-api-gateway)

## [Comment choisir la bonne API Gateway pour votre entreprise ?](https://api7.ai/blog/how-to-choose-right-api-gateway)

Table of Contents

- [Pourquoi utiliser le traitement par lots des requêtes ?](#pourquoi-utiliser-le-traitement-par-lots-des-requ%C3%AAtes-)

- [Exemples concrets de traitement par lots des requêtes](#exemples-concrets-de-traitement-par-lots-des-requ%C3%AAtes)

  - [Exemple 1 :](#exemple-1-)
  - [Exemple 2 :](#exemple-2-)
  - [Exemple 3 :](#exemple-3-)

- [Traitement par lots des requêtes avec Apache APISIX API Gateway](#traitement-par-lots-des-requ%C3%AAtes-avec-apache-apisix-api-gateway)

- [Démonstration du plugin batch-requests](#d%C3%A9monstration-du-plugin-batch-requests)

  - [Prérequis](#pr%C3%A9requis)
  - [Configurer le service backend (upstream)](#configurer-le-service-backend-upstream)
  - [Créer une Route pour l'API de traitement par lots](#cr%C3%A9er-une-route-pour-lapi-de-traitement-par-lots)
  - [Créer une Route pour les points de terminaison des sujets et sessions de l'intervenant](#cr%C3%A9er-une-route-pour-les-points-de-terminaison-des-sujets-et-sessions-de-lintervenant)
  - [Tester le traitement par lots des requêtes](#tester-le-traitement-par-lots-des-requ%C3%AAtes)

- [Points à retenir](#points-%C3%A0-retenir)

- [Prochaines étapes](#prochaines-%C3%A9tapes)

  - [Contenu recommandé](#contenu-recommand%C3%A9)

## Related Posts

[![Enchaînement des requêtes API avec API Gateway](https://static.api7.ai/uploads/2024/12/24/aqS5sC66_chaining-api-requests.png)](https://api7.ai/fr/blog/chaining-api-requests-with-api-gateway)

Technology

May 23, 2023

#### [Enchaînement des requêtes API avec API Gateway](https://api7.ai/fr/blog/chaining-api-requests-with-api-gateway)

Dans cet article, nous allons créer un plugin personnalisé pour la passerelle API Apache APISIX afin de gérer les requêtes client qui doivent être appelées en séquence.

[API Gateway Concept](https://api7.ai/tags/api-gateway-concept)

[Request Processing](https://api7.ai/tags/request-processing)

[Plugin](https://api7.ai/tags/plugin)

[![Une décision réelle de passerelle API : Au cœur du processus d'évaluation technique](https://static.api7.ai/uploads/2025/06/03/E7OqOddo_api-gateway-decision.webp)](https://api7.ai/fr/blog/api-gateway-decision-inside-technical-evaluation)

Technology

June 3, 2025

#### [Une décision réelle de passerelle API : Au cœur du processus d'évaluation technique](https://api7.ai/fr/blog/api-gateway-decision-inside-technical-evaluation)

Découvrez le processus d'évaluation d'une passerelle API en situation réelle, en soulignant la flexibilité, les performances et les avantages open source d'Apache APISIX.

[API Gateway Concept](https://api7.ai/tags/api-gateway-concept)

[![Comprendre le rôle des API Gateways dans l'architecture Microservices](https://static.api7.ai/uploads/2025/02/11/Ubz9z2FG_api-gateways-in-microservices.png)](https://api7.ai/fr/blog/api-gateways-in-microservices-architecture)

Technology

February 11, 2025

#### [Comprendre le rôle des API Gateways dans l'architecture Microservices](https://api7.ai/fr/blog/api-gateways-in-microservices-architecture)

Les API gateways simplifient les microservices en gérant les requêtes, en renforçant la sécurité et en améliorant l'évolutivité, servant de point d'entrée unifié pour les clients.

[Mircoservices](https://api7.ai/tags/mircoservices)

[API Gateway Concept](https://api7.ai/tags/api-gateway-concept)
