---
title: "Alimenter les capacités de l'IA avec Apache APISIX et l'API OpenAI - API7.ai"
description: "Dans cet article de blog, nous explorerons les avantages de l'intégration d'Apache APISIX avec l'API OpenAI et comment vous pouvez utiliser Apache APISIX pour créer une intégration d'IA plus évolutive, performante et sécurisée."
url: "https://api7.ai/fr/blog/power-ai-capabilities-with-apache-apisix"
---

[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

# Alimenter les capacités de l'IA avec Apache APISIX et l'API OpenAI

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

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

February 7, 2023

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

**L'intelligence artificielle** (IA) a révolutionné la manière dont nous interagissons avec la technologie et est devenue une partie intégrante des applications modernes. L'[API OpenAI](https://openai.com/api/) offre aux développeurs des capacités d'IA puissantes, leur permettant de créer des applications d'IA avancées avec facilité.

Cependant, à mesure que l'utilisation de l'IA se développe, le besoin d'intégrations d'API évolutives, performantes et sécurisées augmente également. C'est là qu'[Apache APISIX](https://apisix.apache.org/) entre en jeu. **Apache APISIX** est une passerelle API open-source haute performance qui fournit des fonctionnalités avancées pour la gestion et la mise à l'échelle des intégrations d'API.

Dans cet article de blog, nous explorerons les **avantages de l'intégration** d'Apache APISIX avec l'API OpenAI et comment vous pouvez utiliser Apache APISIX pour créer une intégration d'IA plus **évolutive, performante et sécurisée**. De la mise en cache des proxys aux fonctionnalités de sécurité, nous couvrirons tout ce que vous devez savoir pour commencer avec l'intégration d'Apache APISIX et de l'API OpenAI. Que vous soyez un développeur d'IA ou un professionnel DevOps, cet article de blog est votre guide complet pour créer une intégration d'IA puissante et rentable.

## Objectifs d'apprentissage

Vous apprendrez les éléments suivants tout au long de l'article :

- Qu'est-ce que l'API OpenAI et Apache APISIX ?
- Les avantages de l'utilisation d'Apache APISIX avec l'API OpenAI.
- Plusieurs cas d'utilisation des plugins Apache APISIX pour améliorer l'API OpenAI.
- Comment créer une nouvelle [Route](https://apisix.apache.org/docs/apisix/terminology/route/) dans APISIX pour l'API OpenAI.
- Comment ajouter le point de terminaison de l'API OpenAI en tant que [Upstream](https://apisix.apache.org/docs/apisix/terminology/upstream/) pour la route.
- Comment configurer **l'authentification, la limitation de débit et la mise en cache** pour la route selon les besoins.
- Comment tester la route pour s'assurer que les requêtes sont correctement transférées vers l'API OpenAI.

## Qu'est-ce que l'API OpenAI ?

**OpenAI** est une plateforme de pointe pour créer et déployer des modèles d'intelligence artificielle avancés. Ces modèles peuvent être utilisés pour diverses tâches, telles que le traitement du langage naturel, la reconnaissance d'images et l'analyse de sentiments. L'un des principaux avantages d'OpenAI est qu'il fournit une API que les développeurs peuvent utiliser pour accéder à ces modèles et les intégrer dans leurs applications.

L'API OpenAI est une plateforme basée sur le cloud qui donne accès aux modèles d'IA d'OpenAI, y compris [ChatGPT](https://chat.openai.com/). L'API permet aux développeurs d'intégrer des capacités d'IA dans leurs applications.

**ChatGPT** est l'un des modèles d'IA disponibles via l'API OpenAI, et il est particulièrement bien adapté aux cas d'utilisation nécessitant des capacités de traitement du langage naturel et de génération de texte. Par exemple, ChatGPT peut être utilisé pour générer des réponses textuelles dans un chatbot, fournir des suggestions de [complétion de texte](https://platform.openai.com/docs/guides/completion), de [complétion de code](https://platform.openai.com/docs/guides/code/introduction) ou répondre à des questions dans une interface conversationnelle.

## Qu'est-ce qu'Apache APISIX ?

[Apache APISIX](https://apisix.apache.org/) est une solution open-source de gestion du trafic API native du cloud qui offre des fonctionnalités de passerelle API pour créer des API RESTful évolutives, sécurisées et hautement disponibles.

En utilisant une passerelle API avec l'API OpenAI, vous pouvez facilement créer et déployer des API évolutives, sécurisées et hautes performances qui accèdent aux modèles d'OpenAI. Cela vous permettra d'intégrer la puissance d'OpenAI dans vos applications et de fournir une excellente expérience à vos utilisateurs.

## Quels sont les avantages de l'utilisation d'Apache APISIX avec l'API OpenAI ?

Il y a plusieurs avantages à utiliser Apache APISIX avec l'API OpenAI :

1. **Évolutivité :** Apache APISIX offre un moyen simple de gérer et de mettre à l'échelle l'API OpenAI, vous permettant de gérer une augmentation du trafic et des demandes d'utilisation.
2. **Performance :** Apache APISIX peut aider à améliorer les performances des requêtes de l'API OpenAI en mettant en cache les réponses et en réduisant la latence. Sécurité : Apache APISIX fournit des fonctionnalités de sécurité telles que le chiffrement et l'authentification, rendant facile la sécurisation de l'accès à l'API OpenAI.
3. **Flexibilité :** Apache APISIX offre une manière flexible de gérer et de contrôler l'accès à l'API OpenAI, vous permettant de personnaliser et de configurer votre intégration selon vos besoins.
4. **Surveillance et analyse :** Apache APISIX fournit une surveillance et une analyse détaillées, vous permettant de suivre et d'optimiser les performances de votre intégration de l'API OpenAI.

## Plugins Apache APISIX pour améliorer l'API OpenAI

Il existe plusieurs plugins Apache APISIX qui peuvent être utilisés pour améliorer l'intégration avec l'API OpenAI. Certains des plugins que vous pouvez utiliser avec l'API OpenAI incluent :

- [rate-limiting](https://apisix.apache.org/docs/apisix/plugins/limit-count/) : Pour limiter le nombre de requêtes API et prévenir une utilisation excessive de l'API OpenAI.
- [authentication](https://apisix.apache.org/docs/apisix/plugins/basic-auth/) : Pour sécuriser l'accès à l'API OpenAI en mettant en œuvre des mécanismes d'authentification et d'autorisation.
- [traffic-control](https://apisix.apache.org/docs/apisix/plugins/request-validation/) : Pour contrôler le flux du trafic API et assurer une performance et une stabilité constantes de l'API OpenAI.
- [observability](https://apisix.apache.org/docs/apisix/plugins/opentelemetry/) : Pour surveiller et enregistrer les requêtes et réponses API, fournissant une visibilité sur l'utilisation et les performances de l'API OpenAI.
- [caching](https://apisix.apache.org/docs/apisix/plugins/proxy-cache/) : Pour mettre en cache les réponses API et réduire le nombre de requêtes API, améliorant ainsi les performances et réduisant le coût d'utilisation de l'API OpenAI.
- [transformation](https://apisix.apache.org/docs/apisix/plugins/proxy-rewrite/) : Pour modifier les requêtes et réponses API, transformant les données d'un format à un autre, comme JSON en XML.

## Gérer les API OpenAI avec Apache APISIX - Démonstration

Avec suffisamment de connaissances théoriques en tête, nous pouvons maintenant passer à une session pratique. Dans cet exemple, Apache APISIX est utilisé pour créer une passerelle API simple qui accède à l'API OpenAI et gère le trafic en créant une route, un upstream et en activant certains plugins. Nous allons interagir avec le point de terminaison [Completion](https://platform.openai.com/docs/api-reference/completions) de l'API OpenAI pour créer un générateur de descriptions de produits afin de générer des descriptions de produits de manière efficace et précise.

Par exemple, une requête typique à la passerelle API ressemblera à ce qui suit :

```
curl http://127.0.0.1:9080/openai/product/desc  -X POST -d
'{
   "model":"text-davinci-003",
   "prompt":"Write a brief product description for Apple 13 pro",
   "temperature":0,
   "max_tokens":256
}'
```

Et, nous obtiendrons comme sortie :

```
{
   "object":"text_completion",
   "model":"text-davinci-003",
   "choices":[
      {
         "text":"\n\nThe Apple 13 Pro is the perfect laptop for those who need a powerful and reliable machine.
It features a 13-inch Retina display with True Tone technology, a powerful 8th-generation Intel Core i5 processor, 8GB of RAM, and a 256GB SSD for storage.
It also has a Touch Bar and Touch ID for added security and convenience. With up to 10 hours of battery life, you can stay productive all day long.
The Apple 13 Pro is the perfect laptop for those who need a powerful and reliable machine.",
         "index":0,
         "finish_reason":"stop"
      }
   ],
   "usage":{
      "prompt_tokens":9,
      "completion_tokens":109,
      "total_tokens":118
   }
}
```

### Prérequis

- Doit être familier avec les concepts fondamentaux du modèle de [complétion](https://platform.openai.com/docs/guides/completion/introduction) de l'API OpenAI.
- Créer une [clé API OpenAI](https://platform.openai.com/docs/api-reference/authentication) : Pour accéder à l'API OpenAI, vous devrez créer une clé API. Vous pouvez le faire en vous connectant au site web d'OpenAI et en naviguant vers la page de gestion des clés API.
- [Docker](https://www.docker.com/products/docker-desktop/) installé sur votre machine pour exécuter APISIX.
- Connaissance de base de quelques concepts clés d'APISIX tels que [Route](https://apisix.apache.org/docs/apisix/terminology/route/), [Upstream](https://apisix.apache.org/docs/apisix/terminology/upstream/) et [Plugin](https://apisix.apache.org/docs/apisix/terminology/plugin/).

### Configuration du projet

La première chose à faire est de cloner le projet [apisix-docker](https://github.com/apache/apisix-docker) depuis [GitHub](https://github.com/) :

```
git clone https://github.com/apache/apisix-docker.git
```

Ouvrez le dossier du projet dans votre éditeur de code préféré. Ce tutoriel utilise [VS Code](https://code.visualstudio.com/).

### Installer et exécuter Apache APISIX

Pour exécuter Apache APISIX, vous pouvez suivre ces étapes :

Ouvrez une nouvelle fenêtre de terminal et exécutez la commande `docker compose up` depuis le dossier racine du projet :

```
docker compose up -d
```

La commande ci-dessus exécutera Apache APISIX et etcd ensemble avec Docker.

> Nous avons installé APISIX en utilisant Docker dans cette démonstration. Cependant, il existe d'autres options pour l'installer dans le [guide d'installation](https://apisix.apache.org/docs/apisix/installation-guide/).

### Créer un Upstream pour l'API OpenAI

Une fois la configuration terminée, nous allons créer un objet [Upstream](https://apisix.apache.org/docs/apisix/terminology/upstream/) dans APISIX en utilisant son [API Admin](https://apisix.apache.org/docs/apisix/admin-api/). "*Upstream*" dans APISIX fait référence aux serveurs backend qui sont responsables de servir les données de requête réelles.

Dans notre cas, nous définissons le serveur API upstream à `api.openai.com` avec un seul nœud et le schéma `https` utilisé pour communiquer de manière sécurisée avec l'Upstream :

```
curl "http://127.0.0.1:9180/apisix/admin/upstreams/1" -H "X-API-KEY: edd1c9f034335f136f87ad84b625c8f1" -X PUT -d '
{
  "name": "OpenAI API upstream",
  "desc": "Add the OpenAI API domain as the upstream",
  "type": "roundrobin",
  "scheme": "https",
  "nodes": {
    "api.openai.com:443": 1
  }
}'
```

### Créer une nouvelle configuration de plugin

Maintenant, nous créons une nouvelle configuration de plugin avec le plugin [proxy-rewrite](https://apisix.apache.org/docs/apisix/plugins/proxy-rewrite/) activé.

Le plugin proxy est utilisé pour redéfinir les requêtes vers le point de terminaison de complétion de l'API OpenAI. La configuration du plugin inclut des options pour définir l'URL du point de terminaison de l'API, transmettre la clé API OpenAI en tant qu'en-tête, et avec l'en-tête `Content-Type` défini sur `application/json`.

```
curl http://127.0.0.1:9180/apisix/admin/plugin_configs/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
   "plugins":{
      "proxy-rewrite":{
         "uri":"/v1/completions",
         "host":"api.openai.com",
         "headers":{
            "Authorization":"OpenAI API Key",
            "Content-Type":"application/json"
         }
      }
   }
}'
```

### Configurer une Route pour le point de terminaison de complétion de l'API OpenAI

Dans l'étape suivante, nous configurons une nouvelle Route dans APISIX pour gérer les requêtes `POST` avec un nouveau chemin d'URI de passerelle API personnalisé `/openai/product/desc`, et nous faisons référence à l'upstream et à la configuration de plugin créés dans les étapes précédentes par leurs identifiants uniques.

```
curl -i http://127.0.0.1:9180/apisix/admin/routes/1 \
-H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
   "name":"OpenAI API completion route",
   "desc":"Create a new route in APISIX for the OpenAI API completion endpoint",
   "methods":[
      "POST"
   ],
   "uri":"/openai/product/desc",
   "upstream_id":"1",
   "plugin_config_id":1
}'
```

> De plus, la route est configurée avec des tentatives de réessai, un délai d'attente et un délai de maintien de la connexion pour assurer une communication robuste et résiliente avec l'API OpenAI.

### Tester avec une requête Curl

Pour tester l'API, vous pouvez faire une requête POST vers le point de terminaison `/openai/product/desc` en utilisant un outil comme cURL ou Postman. La passerelle API transférera la requête vers le point de terminaison de complétion de l'API OpenAI et retournera les résultats avec succès.

```
curl http://127.0.0.1:9080/openai/product/desc  -X POST -d
'{
   "model":"text-davinci-003",
   "prompt":"Write a brief product description for Apple 13 pro",
   "temperature":0,
   "max_tokens":256
}'
```

Super ! Nous avons obtenu une réponse du point de terminaison de complétion réel :

```
HTTP/1.1 200 OK
Content-Type: application/json
...
{
   "object":"text_completion",
   ...
   "choices":[
      {
         "text":"\n\nThe Apple 13 Pro is the perfect laptop...",
         "index":0,
         "logprobs":null,
         "finish_reason":"stop"
      }
   ],
...
}
```

### Créer un nouveau consommateur et ajouter l'authentification

Jusqu'à présent, notre point de terminaison de génération de descriptions de produits `/openai/product/desc` est public et accessible par des utilisateurs non autorisés (bien que la communication entre APISIX et l'API OpenAI soit sécurisée avec la clé API dans l'en-tête). Dans cette section, nous allons activer la fonctionnalité d'authentification pour interdire les requêtes non autorisées à notre API.

Pour ce faire, nous devons créer un nouveau consommateur pour notre point de terminaison et ajouter le plugin [basic-auth](https://apisix.apache.org/docs/apisix/plugins/basic-auth/) à la configuration de plugin existante afin que seuls les utilisateurs autorisés puissent y accéder.

La commande ci-dessous créera notre nouveau `consumer1` avec ses identifiants tels que `username1` et `password1` :

```
curl http://127.0.0.1:9180/apisix/admin/consumers -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
    "username": "consumer1",
    "plugins": {
        "basic-auth": {
            "username": "username1",
            "password": "password1"
        }
    }
}'
```

Maintenant, nous mettons à jour la configuration de plugin existante et ajoutons le plugin `basic-auth` pour permettre à la route d'APISIX de vérifier les identifiants du consommateur dans l'en-tête de la requête à chaque fois que les API sont appelées :

```
curl http://127.0.0.1:9180/apisix/admin/plugin_configs/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
   "plugins":{
      "proxy-rewrite":{
         "uri":"/v1/completions",
         "host":"api.openai.com",
         "headers":{
            "Authorization":"OpenAI API Key",
            "Content-Type":"application/json"
         }
      },
      "basic-auth":{}
   }
}'
```

Maintenant, seulement si nous fournissons les identifiants corrects dans la requête et accédons au même point de terminaison, nous pouvons obtenir la réponse attendue de l'API OpenAI :

```
curl -i -u username1:password1 http://127.0.0.1:9080/openai/product/desc  -X POST -d \
'{
   "model":"text-davinci-003",
   "prompt":"Write a brief product description for Apple 13 pro",
   "temperature":0,
   "max_tokens":256
}'
```

### Appliquer des politiques de limitation de débit pour les API serverless

Dans cette section, nous allons protéger notre point de terminaison de génération de descriptions de produits contre les abus en appliquant une politique de limitation de débit. Dans la passerelle Apache APISIX, nous pouvons appliquer une limitation de débit pour restreindre le nombre d'appels entrants.

#### Appliquer et tester la politique de limitation de débit

Avec la configuration de route existante, nous pouvons appliquer une politique de limitation de débit avec le plugin [limit-count](https://apisix.apache.org/docs/apisix/plugins/limit-count/) pour protéger notre API contre une utilisation anormale. Nous limiterons le nombre d'appels API à 2 par 60s par consommateur API.

Pour activer le plugin `limit-count` pour la route existante, nous devons ajouter le plugin à la liste des plugins dans notre configuration JSON :

```
curl http://127.0.0.1:9180/apisix/admin/plugin_configs/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
   "plugins":{
      "proxy-rewrite":{
         "uri":"/v1/completions",
         "host":"api.openai.com",
         "headers":{
            "Authorization":"OpenAI API Key",
            "Content-Type":"application/json"
         }
      },
      "basic-auth":{},
      "limit-count":{
         "count":2,
         "time_window":60,
         "rejected_code":403,
         "rejected_msg":"Requests are too frequent, please try again later.",
         "key_type":"var",
         "key":"remote_addr"
      }
   }
}'
```

Apache APISIX gérera les deux premières requêtes comme d'habitude. Cependant, une troisième requête dans la même période retournera un code `403 HTTP Forbidden` avec notre message d'erreur personnalisé :

```
curl -i -u username1:password1 http://127.0.0.1:9080/openai/product/desc  -X POST -d \
'{
   "model":"text-davinci-003",
   "prompt":"Write a brief product description for Apple 13 pro",
   "temperature":0,
   "max_tokens":256
}'

# Après le premier appel

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 752
Connection: keep-alive
X-RateLimit-Limit: 2
X-RateLimit-Remaining: 1

# Après le deuxième appel

HTTP/1.1 403 Forbidden

{"error_msg":"Requests are too frequent, please try again later."}
```

### Configurer la mise en cache pour la réponse de l'API OpenAI

La [mise en cache des proxys](https://apisix.apache.org/docs/apisix/plugins/proxy-cache/) d'Apache APISIX est une fonctionnalité d'Apache APISIX qui vous permet de mettre en cache les réponses API et de servir les réponses mises en cache aux requêtes suivantes. Cela peut aider à réduire le nombre de requêtes API, ce qui signifie une réduction du coût d'utilisation de l'API OpenAI, améliorer les performances de votre intégration d'API et réduire la charge sur le serveur API.

Apache APISIX offre un contrôle granulaire sur le comportement de la mise en cache, vous permettant de spécifier le temps d'expiration du cache, les conditions d'invalidation du cache et d'autres politiques de mise en cache.

Dans la configuration ci-dessous, nous allons définir le plugin `proxy-cache` avec d'autres plugins pour mettre en cache uniquement les réponses réussies de descriptions de produits provenant de la méthode `POST` du point de terminaison de complétion de l'API OpenAI.

```
curl http://127.0.0.1:9180/apisix/admin/plugin_configs/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -d '
{
   "plugins":{
      "proxy-rewrite":{
         "uri":"/v1/completions",
         "host":"api.openai.com",
         "headers":{
            "Authorization":"OpenAI API Key",
            "Content-Type":"application/json"
         }
      },
      "basic-auth":{},
      "proxy-cache":{
         "cache_key":[
            "$uri",
            "-cache-id"
         ],
         "cache_method":[
            "POST"
         ],
         "cache_http_status":[
            200
         ],
         "hide_cache_headers":true
      }
   }
}'
```

Nous enverrons plusieurs requêtes au chemin `/openai/product/desc` et nous devrions recevoir une réponse `HTTP 200 OK` à chaque fois. Cependant, l'en-tête `Apisix-Cache-Status` dans la réponse indique `MISS`, ce qui signifie que la réponse n'a pas encore été mise en cache lors de la première requête. Maintenant, si vous faites une autre requête, vous verrez que vous obtenez une réponse mise en cache avec l'indicateur de mise en cache comme `HIT`.

La réponse ressemble à ce qui suit :

```
HTTP/1.1 200 OK
…
Apisix-Cache-Status: MISS
```

Lorsque vous faites un autre appel au service, la route répond à la requête avec une réponse mise en cache puisqu'elle a déjà été mise en cache lors de la requête précédente :

```
HTTP/1.1 200 OK
…
Apisix-Cache-Status: HIT
```

## Résumé

L'intégration d'Apache APISIX et de l'API OpenAI consiste à combiner les fonctionnalités d'Apache APISIX, une passerelle API open-source et haute performance pour les microservices, avec les capacités d'intelligence artificielle avancées de l'API OpenAI pour améliorer la fonctionnalité et les performances des applications. Avec cette intégration, les développeurs peuvent tirer parti de l'évolutivité et des performances d'Apache APISIX pour gérer les microservices tout en exploitant les capacités d'IA de pointe d'OpenAI pour offrir des fonctionnalités sophistiquées et avancées à leurs utilisateurs.

À des stades ultérieurs, vous pouvez déployer à la fois APISIX et le code d'exécution d'OpenAI sur un serveur d'applications ou tout cloud public pour les rendre disponibles en production.

Tout au long de cet article, nous avons démontré seulement quelques exemples de plugins Apache APISIX qui peuvent être utilisés avec l'API OpenAI. Vous pouvez choisir les plugins qui répondent le mieux à vos besoins et personnaliser votre intégration d'Apache APISIX et de l'API OpenAI pour répondre aux exigences spécifiques de vos applications.

### Ressources connexes

- [API OpenAI](https://openai.com/api/)

### Contenu recommandé

- [10 cas d'utilisation les plus courants d'une passerelle API](https://apisix.apache.org/blog/2022/10/27/ten-use-cases-api-gateway/)
- [Comment choisir la bonne passerelle API](https://iambobur.com/2022/11/22/how-to-choose-the-right-api-gateway/)
- [Pourquoi Apache APISIX est la meilleure passerelle API ?](https://api7.ai/blog/why-is-apache-apisix-the-best-api-gateway)

### Communauté

🙋 [Rejoignez la communauté Apache APISIX](https://apisix.apache.org/docs/general/join/) 🐦 [Suivez-nous sur Twitter](https://twitter.com/ApacheAPISIX) 📝 [Retrouvez-nous sur Slack](https://join.slack.com/t/the-asf/shared_invite/zt-vlfbf7ch-HkbNHiU_uDlcH_RvaHv9gQ)

Tags:

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

[APISIX Basics](https://api7.ai/tags/apisix-basics)

[Artificial Intelligence](https://api7.ai/tags/artificial-intelligence)

Share article link

Share

Related Posts

[![Une comparaison approfondie des API Gateways, Kubernetes Gateways et Service Meshes](https://static.api7.ai/uploads/2023/06/07/KS3wtoLx_cover.png)](https://api7.ai/blog/gateway-and-mesh)

## [Une comparaison approfondie des API Gateways, Kubernetes Gateways et Service Meshes](https://api7.ai/blog/gateway-and-mesh)

[![Top 10 des tendances en matière de gestion des API pour 2023](https://static.api7.ai/uploads/2023/04/12/PtHsoEJS_top-10-trends.png)](https://api7.ai/blog/10-api-management-trends-2023)

## [Top 10 des tendances en matière de gestion des API pour 2023](https://api7.ai/blog/10-api-management-trends-2023)

Table of Contents

- [Objectifs d'apprentissage](#objectifs-dapprentissage)

- [Qu'est-ce que l'API OpenAI ?](#quest-ce-que-lapi-openai-)

- [Qu'est-ce qu'Apache APISIX ?](#quest-ce-quapache-apisix-)

- [Quels sont les avantages de l'utilisation d'Apache APISIX avec l'API OpenAI ?](#quels-sont-les-avantages-de-lutilisation-dapache-apisix-avec-lapi-openai-)

- [Plugins Apache APISIX pour améliorer l'API OpenAI](#plugins-apache-apisix-pour-am%C3%A9liorer-lapi-openai)

- [Gérer les API OpenAI avec Apache APISIX - Démonstration](#g%C3%A9rer-les-api-openai-avec-apache-apisix---d%C3%A9monstration)

  - [Prérequis](#pr%C3%A9requis)
  - [Configuration du projet](#configuration-du-projet)
  - [Installer et exécuter Apache APISIX](#installer-et-ex%C3%A9cuter-apache-apisix)
  - [Créer un Upstream pour l'API OpenAI](#cr%C3%A9er-un-upstream-pour-lapi-openai)
  - [Créer une nouvelle configuration de plugin](#cr%C3%A9er-une-nouvelle-configuration-de-plugin)
  - [Configurer une Route pour le point de terminaison de complétion de l'API OpenAI](#configurer-une-route-pour-le-point-de-terminaison-de-compl%C3%A9tion-de-lapi-openai)
  - [Tester avec une requête Curl](#tester-avec-une-requ%C3%AAte-curl)
  - [Créer un nouveau consommateur et ajouter l'authentification](#cr%C3%A9er-un-nouveau-consommateur-et-ajouter-lauthentification)
  - [Appliquer des politiques de limitation de débit pour les API serverless](#appliquer-des-politiques-de-limitation-de-d%C3%A9bit-pour-les-api-serverless)
  - [Configurer la mise en cache pour la réponse de l'API OpenAI](#configurer-la-mise-en-cache-pour-la-r%C3%A9ponse-de-lapi-openai)

- [Résumé](#r%C3%A9sum%C3%A9)

  - [Ressources connexes](#ressources-connexes)
  - [Contenu recommandé](#contenu-recommand%C3%A9)
  - [Communauté](#communaut%C3%A9)

## Related Posts

[![API Gateway vs. Gestion des API](https://static.api7.ai/uploads/2024/12/25/zQTHfZGV_api-gateway-vs-api-management.jpg)](https://api7.ai/fr/blog/api-gateway-and-api-management-comparison)

Technology

September 1, 2023

#### [API Gateway vs. Gestion des API](https://api7.ai/fr/blog/api-gateway-and-api-management-comparison)

Découvrez ce que sont l'API gateway et la gestion des API, et explorez leurs relations et différences.

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

[API Management](https://api7.ai/tags/api-management)

[APISIX Basics](https://api7.ai/tags/apisix-basics)

[![Sessions persistantes avec Apache APISIX - Théorie](https://static.api7.ai/uploads/2023/07/28/d33oDxuF_Sticky-Sessions.png)](https://api7.ai/fr/blog/sticky-sessions-theory)

Technology

July 27, 2023

#### [Sessions persistantes avec Apache APISIX - Théorie](https://api7.ai/fr/blog/sticky-sessions-theory)

Découvrons les raisons derrière les sessions persistantes (sticky sessions), les alternatives disponibles et comment les implémenter via Apache APISIX.

[APISIX Basics](https://api7.ai/tags/apisix-basics)

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

[Sticky Sessions](https://api7.ai/tags/sticky-sessions)

[![Développement de plugins personnalisés pour APISIX avec Lua et ChatGPT](https://static.api7.ai/uploads/2024/12/25/MssMP69w_custom-plugin-development.png)](https://api7.ai/fr/blog/plugin-development-with-lua-and-chatgpt)

Technology

June 12, 2023

#### [Développement de plugins personnalisés pour APISIX avec Lua et ChatGPT](https://api7.ai/fr/blog/plugin-development-with-lua-and-chatgpt)

Cet article vous guidera à travers le processus de développement d'un nouveau plugin personnalisé appelé file-proxy pour APISIX en utilisant Lua et ChatGPT.

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

[APISIX Basics](https://api7.ai/tags/apisix-basics)

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