---
title: "Gestion d'une application Java alimentée par l'IA avec API Management - API7.ai"
description: "Dans cet article, nous explorerons comment intégrer les API ChatGPT d'OpenAI avec une application Spring Boot et gérer ces API à l'aide d'Apache APISIX."
url: "https://api7.ai/fr/blog/managing-ai-powered-java-apps"
---

[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

# Gestion d'une application Java alimentée par l'IA avec API Management

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

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

June 22, 2023

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

Dans cet article, nous allons **explorer comment intégrer** l'[API ChatGPT d'OpenAI](https://platform.openai.com/docs/api-reference/introduction) avec une application [Spring Boot](https://spring.io/projects/spring-boot) et gérer les API à l'aide d'[Apache APISIX](https://apisix.apache.org/), un **passerelle API open-source**. Cette intégration nous permettra de tirer parti de la puissance de ChatGPT, un modèle de langage de pointe développé par [OpenAI](https://openai.com/), dans notre application Spring Boot, tandis qu'APISIX fournira une manière robuste, évolutive et sécurisée de gérer les API.

## API ChatGPT d'OpenAI

L'[API ChatGPT d'OpenAI](https://platform.openai.com/docs/api-reference/introduction) est un outil puissant que nous pouvons utiliser pour **intégrer les capacités du modèle ChatGPT** dans nos propres applications ou services. L'API nous permet d'envoyer une série de messages et de recevoir une réponse générée par un modèle d'IA via REST. Elle propose un ensemble d'API pour créer des réponses textuelles dans un chatbot, compléter du code, générer des images ou répondre à des questions dans une interface conversationnelle. Dans ce tutoriel, nous utiliserons l'[API de complétion de chat](https://platform.openai.com/docs/api-reference/chat/create) pour générer des réponses à une invite (en gros, nous pouvons poser n'importe quelle question). Avant de commencer le tutoriel, vous pouvez explorer l'API pour comprendre comment [s'authentifier à l'API](https://platform.openai.com/docs/api-reference/authentication) à l'aide de clés API, à quoi ressemblent les paramètres de requête et la réponse de l'API.

Un exemple de requête cURL à l'[API de complétion de chat](https://platform.openai.com/docs/api-reference/chat/create) ressemblerait à ceci. Vous remplacez `OPENAI_API_KEY` par votre propre [clé API](https://platform.openai.com/account/api-keys) et la placez dans l'en-tête *Authorization* lors de l'appel de l'API.

```
curl https://api.openai.com/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [{"role": "user", "content": "What is Apache APISIX?"}]
}'
```

Voici un exemple de réponse JSON :

```
{
  "id": "chatcmpl-7PtycrYOTJGv4jw8FQPD7LCCw0tOE",
  "object": "chat.completion",
  "created": 1686407730,
  "model": "gpt-3.5-turbo-0301",
  "usage": {
    "prompt_tokens": 15,
    "completion_tokens": 104,
    "total_tokens": 119
  },
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "Apache APISIX est une passerelle API dynamique, en temps réel et haute performance conçue pour faciliter la gestion et le routage des microservices et des API. Elle fournit des fonctionnalités telles que l'équilibrage de charge, la limitation de débit, l'authentification, l'autorisation et le contrôle du trafic, qui aident à simplifier la gestion des microservices et des API. Apache APISIX est construit sur le serveur Nginx et peut supporter des niveaux élevés de trafic avec une faible latence et une haute disponibilité. Il est open source et publié sous la licence Apache 2.0."
      },
      "finish_reason": "stop",
      "index": 0
    }
  ]
}
```

## Exemple de code du projet

Le tutoriel se compose de deux parties. La première partie couvre la configuration de l'application Spring Boot et la création d'un nouveau point de terminaison API qui peut gérer nos appels API à l'[API de complétion de chat](https://platform.openai.com/docs/api-reference/chat/create) de manière programmatique. Dans la deuxième partie, nous introduirons les fonctionnalités d'APISIX telles que la sécurité et le contrôle du trafic à l'API Spring Boot. Les exemples de code complets pour ce tutoriel sont disponibles sur le dépôt GitHub appelé [apisix-java-chatgpt-openaiapi](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi).

### Prérequis

Avant de commencer, assurez-vous d'avoir les éléments suivants :

- Créez 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/) est installé sur votre machine pour exécuter APISIX et Spring Boot.

### Étape 1 : Configuration de votre application Spring Boot

Tout d'abord, nous devons configurer une nouvelle application Spring Boot. Vous pouvez utiliser [Spring Initializr](https://start.spring.io/) pour générer un nouveau projet Maven avec les dépendances nécessaires. Pour ce tutoriel, nous aurons besoin de la dépendance [Spring Boot Starter Web](https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web). Pour intégrer l'API ChatGPT, nous utiliserons le client Java OpenAI. Il existe une [bibliothèque communautaire open-source](https://platform.openai.com/docs/libraries/community-libraries) appelée <https://github.com/TheoKanning/openai-java>. Elle fournit des classes de service qui créent et appellent le client des API GPT d'OpenAI en Java. Bien sûr, vous pouvez également écrire votre propre implémentation dans Spring qui interagit avec les API OpenAI. Voir d'autres [bibliothèques clientes](https://platform.openai.com/docs/libraries) pour différents langages de programmation.

```
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.theokanning.openai-gpt3-java</groupId>
            <artifactId>service</artifactId>
            <version>0.12.0</version>
        </dependency>
</dependencies>
```

### Étape 2 : Créer une classe Controller

Dans la classe [ChatCompletionController.java](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/blob/main/openaiapi/src/main/java/com/company/project/controllers/ChatCompletionController.java), vous pouvez utiliser le service OpenAI pour envoyer une requête à l'API ChatGPT.

```
import com.theokanning.openai.completion.chat.ChatCompletionChoice;
import com.theokanning.openai.completion.chat.ChatCompletionRequest;
import com.theokanning.openai.completion.chat.ChatMessage;
import com.theokanning.openai.completion.chat.ChatMessageRole;
import com.theokanning.openai.service.OpenAiService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;

@RestController
public class ChatCompletionController {

    @Value("${openai.model}")
    private String model;

    @Value("${openai.api.key}")
    private String openaiApiKey;

    @PostMapping("/ai-chat")
    public String chat(@RequestBody String prompt) {
        OpenAiService service = new OpenAiService(openaiApiKey);

        final List<ChatMessage> messages = new ArrayList<>();
        final ChatMessage systemMessage = new ChatMessage(
       ChatMessageRole.USER.value(), prompt);
        messages.add(systemMessage);

        ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest
            .builder()
            .model(model)
            .messages(messages)
            .maxTokens(250)
            .build();

        List<ChatCompletionChoice> choices = service
      .createChatCompletion(chatCompletionRequest).getChoices();

        if (choices == null || choices.isEmpty()) {
            return "No response";
        }

        return choices.get(0).getMessage().getContent();
    }
}
```

Le point de terminaison API `/ai-chat` gère les requêtes POST, crée une requête de chat et l'envoie à l'API OpenAI. Ensuite, il renvoie le premier message de la réponse de l'API.

### Étape 3 : Définir les propriétés de l'application

Ensuite, nous fournissons les propriétés pour l'API comme `model` et `clé API` dans le fichier *[application.properties](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/blob/main/openaiapi/src/main/resources/application.properties)* :

```
openai.model=gpt-3.5-turbo
openai.api.key=YOUR_OPENAI_API_TOKEN
```

### Étape 4 : Exécuter l'application Spring Boot

Nous pouvons maintenant exécuter [Application.java](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/blob/main/openaiapi/src/main/java/com/company/project/Application.java) et la tester avec Postman ou la commande cURL.

![Réponse IA de Spring Boot](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6wmykn27qfj7dca0garv.png?imageMogr2/format/webp)

Comme nous pouvons le voir, l'application a généré une réponse à notre question dans le corps de la requête d'invite.

### Étape 5 : Créer un Dockerfile

Nous utilisons un conteneur Docker pour encapsuler notre application Spring Boot et l'utiliser avec d'autres conteneurs APISIX dans [docker-compose.yml](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/blob/main/docker-compose.yml). Pour ce faire, nous pouvons créer un [Dockerfile](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/blob/main/openaiapi/Dockerfile) pour construire un JAR et l'exécuter. Voir le tutoriel sur la [dockerisation d'une application Spring Boot](https://spring.io/guides/topicals/spring-boot-docker/). Ensuite, enregistrez le service dans le fichier yaml de docker compose.

```
openaiapi:
    build: openaiapi
    ports:
      - "8080:8080"
    networks:
      apisix:
```

### Étape 6 : Configuration d'Apache APISIX

Pour configurer APISIX, nous pouvons simplement exécuter la commande `docker compose up`. Parce que nous avons déjà défini tous les services nécessaires dans [docker-compose.yml](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/blob/main/docker-compose.yml). Ce fichier définit seulement 2 conteneurs, un pour APISIX et un autre pour l'application Spring Boot que nous avons implémentée dans les étapes précédentes. Dans ce projet d'exemple, nous exécutons APISIX en [mode autonome](https://apisix.apache.org/docs/apisix/2.15/stand-alone/). Il existe d'autres [options d'installation](https://apisix.apache.org/docs/apisix/installation-guide/) et [modes de déploiement](https://apisix.apache.org/docs/apisix/deployment-modes/) pour APISIX. Maintenant, APISIX en tant que service séparé fonctionne sur `localhost:9080` et l'application Spring Boot sur **`localhost:8080`**

### Étape 7 : Sécuriser l'API avec APISIX

Une fois APISIX configuré, nous pouvons ajouter des fonctionnalités de sécurité à notre API Spring Boot existante `/ai-chat` afin que seuls les consommateurs d'API autorisés puissent accéder à cette API. APISIX fournit plusieurs plugins pour sécuriser vos API. Par exemple, vous pouvez utiliser le plugin [jwt-auth](https://apisix.apache.org/docs/apisix/plugins/jwt-auth/) pour exiger un jeton JWT pour toutes les requêtes. Voici un exemple de comment ajouter une route avec un upstream et des plugins en utilisant le fichier `apisix.yml` :

```
upstreams:
  - id: 1
    type: roundrobin
    nodes:
      "openaiapi:8080": 1
routes:
  - uri: /ask-me-anything
    upstream_id: 1
    plugins:
      proxy-rewrite:
        uri: /ai-chat
      jwt-auth: {}
  - uri: /login
    plugins:
      public-api:
        uri: /apisix/plugin/jwt/sign
consumers:
  - username: appsmithuser
    plugins:
        jwt-auth:
            key: appsmithuser@gmail.com
            secret: my-secret-key
```

> Après avoir spécifié les upstreams, les routes et les objets consommateurs ainsi que les règles de routage dans la configuration d'APISIX, le fichier de configuration est chargé en mémoire immédiatement après le démarrage du service de nœud APISIX dans Docker. Apisix essaie périodiquement de détecter si le contenu du fichier est mis à jour, s'il y a une mise à jour, il **recharge automatiquement les changements**.

Avec cette configuration, nous avons ajouté un upstream, deux routes et un objet consommateur. Dans la première route, toutes les requêtes à `/ask-me-anything` (qui est un chemin d'URI personnalisé, vous pouvez définir n'importe quel URI ici) doivent inclure l'en-tête `Authorization: JWT_TOKEN`. Ensuite, APISIX réécrit le chemin d'URI personnalisé vers l'API réelle `/ai-chat` automatiquement à l'aide du plugin [proxy-rewrite](https://apisix.apache.org/docs/apisix/plugins/proxy-rewrite/) et transfère les requêtes à l'application Spring Boot fonctionnant sur `localhost:8080`.

Si vous essayez de demander la route APISIX, elle rejettera nos requêtes en renvoyant une erreur d'autorisation :

```
curl -i http://localhost:9080/ask-me-anything -X POST -d '
{
   "prompt":"What is Apache APISIX?"
}'
```

Le résultat de la requête ci-dessus :

```
HTTP/1.1 401 Unauthorized
{"message":"Missing JWT token in request"}
```

Dans la deuxième configuration de route, nous avons activé le plugin [public-api](https://apisix.apache.org/docs/apisix/plugins/public-api/) pour exposer un nouveau point de terminaison `/login` pour signer de nouveaux jetons JWT. Parce qu'APISIX peut agir comme un fournisseur d'identité pour générer et valider un nouveau jeton pour le consommateur d'API ou les applications clientes. Voir **Étape 8**, comment nous réclamons un nouveau jeton pour notre consommateur d'API.

```
  - uri: /login
    plugins:
      public-api:
        uri: /apisix/plugin/jwt/sign
```

Si vous avez remarqué dans le même fichier de configuration, nous avons enregistré un consommateur d'API pour utiliser l'API `/ask-me-anything` alimentée par l'IA et nos utilisateurs peuvent réclamer APISIX en utilisant leur secret pour générer un jeton JWT pour accéder à l'API :

```
consumers:
  - username: appsmithuser
    plugins:
        jwt-auth:
            key: appsmithuser@gmail.com
            secret: my-secret-key
```

### Étape 8 : Réclamer un nouveau jeton JWT

Maintenant, nous pouvons réclamer un nouveau jeton JWT pour notre consommateur d'API existant avec la clé :

```
curl -i http://127.0.0.1:9080/login?key=user-key -i
```

Nous obtiendrons le nouveau jeton en réponse d'APISIX :

```
Server: APISIX/3.0.0
eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJrZXkiOiJ1c2VyLWtleSIsImV4cCI6MTY4NjU5MjE0NH0.4Kn9c2DBYKthyUx824Ah97-z0Eu2Ul9WGO2WB3IfURA
```

### Étape 9 : Demander l'API avec le jeton JWT

Enfin, nous pouvons envoyer une requête à l'API `/ask-me-anything` avec le jeton JWT dans l'en-tête que nous avons obtenu à l'étape précédente.

```
curl -i http://localhost:9080/ask-me-anything -H 'Authorization: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJrZXkiOiJ1c2VyLWtleSIsImV4cCI6MTY4NjU5Mjk4N30.lhom9db3XMkcVd86ScpM6s4eP1_YzR-tfmXPckszsYo' -X POST -d '
{
   "prompt":"What is Apache APISIX?"
}'
```

Ou en utilisant Postman, nous obtiendrons une réponse IA mais cette fois la réponse passe par la passerelle APISIX :

![Réponse IA d'APISIX](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6bu426xjmowx6jnf7e80.png?imageMogr2/format/webp)

## Conclusion

Dans ce tutoriel, nous avons exploré l'API ChatGPT d'OpenAI pour générer des réponses à des invites. Nous avons créé une application Spring Boot qui appelle l'API pour générer des réponses à des invites. Ensuite, vous pouvez introduire [des fonctionnalités supplémentaires](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/tree/main/additional-features) à votre intégration en mettant à jour le fichier [apisix.yml](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/blob/with-frontend/apisix/apisix.yml) existant. Vous pouvez également consulter la branche appelée [with-frontend](https://github.com/Boburmirzo/apisix-java-chatgpt-openaiapi/tree/with-frontend) et exécuter le projet pour voir l'interface utilisateur construite avec [Appsmith](https://www.appsmith.com/) qui fonctionne avec APISIX.

### Ressources connexes

- [Bibliothèque Java de l'API OpenAI](https://github.com/TheoKanning/openai-java)
- [API de complétion de chat OpenAI](https://platform.openai.com/docs/api-reference/chat/create)

### Contenu recommandé

- [Alimenter les capacités IA avec Apache APISIX et l'API OpenAI](https://api7.ai/blog/power-ai-capabilities-with-apache-apisix)
- [Pourquoi Apache APISIX est-il la meilleure passerelle API ?](https://api7.ai/blog/why-is-apache-apisix-the-best-api-gateway)

Tags:

[Java](https://api7.ai/tags/java)

[Spring Boot Web API](https://api7.ai/tags/spring-boot-web-api)

[Managing Java APIs](https://api7.ai/tags/managing-java-apis)

[API Gateway for ChatGPT](https://api7.ai/tags/api-gateway-for-chatgpt)

Share article link

Share

Related Posts

[![Maximiser la gestion des API avec l'IA : meilleures pratiques et insights](https://static.api7.ai/uploads/2025/02/19/cVn3NoxN_maximize-api-management-with-ai.png)](https://api7.ai/blog/maximize-api-management-with-ai)

## [Maximiser la gestion des API avec l'IA : meilleures pratiques et insights](https://api7.ai/blog/maximize-api-management-with-ai)

[![Gestion des API pilotée par l'IA : Amélioration de la sécurité et des performances](https://static.api7.ai/uploads/2025/02/19/Xz2zhWby_ai-driven-api-management.png)](https://api7.ai/blog/ai-driven-api-management)

## [Gestion des API pilotée par l'IA : Amélioration de la sécurité et des performances](https://api7.ai/blog/ai-driven-api-management)

Table of Contents

- [API ChatGPT d'OpenAI](#api-chatgpt-dopenai)

- [Exemple de code du projet](#exemple-de-code-du-projet)

  - [Prérequis](#pr%C3%A9requis)
  - [Étape 1 : Configuration de votre application Spring Boot](#%C3%A9tape-1--configuration-de-votre-application-spring-boot)
  - [Étape 2 : Créer une classe Controller](#%C3%A9tape-2--cr%C3%A9er-une-classe-controller)
  - [Étape 3 : Définir les propriétés de l'application](#%C3%A9tape-3--d%C3%A9finir-les-propri%C3%A9t%C3%A9s-de-lapplication)
  - [Étape 4 : Exécuter l'application Spring Boot](#%C3%A9tape-4--ex%C3%A9cuter-lapplication-spring-boot)
  - [Étape 5 : Créer un Dockerfile](#%C3%A9tape-5--cr%C3%A9er-un-dockerfile)
  - [Étape 6 : Configuration d'Apache APISIX](#%C3%A9tape-6--configuration-dapache-apisix)
  - [Étape 7 : Sécuriser l'API avec APISIX](#%C3%A9tape-7--s%C3%A9curiser-lapi-avec-apisix)
  - [Étape 8 : Réclamer un nouveau jeton JWT](#%C3%A9tape-8--r%C3%A9clamer-un-nouveau-jeton-jwt)
  - [Étape 9 : Demander l'API avec le jeton JWT](#%C3%A9tape-9--demander-lapi-avec-le-jeton-jwt)

- [Conclusion](#conclusion)

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

## Related Posts

[![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)

[![Explication des derniers prix de Kong 2025 et meilleures alternatives à Kong](https://static.api7.ai/uploads/2025/03/10/FKRWNsq8_2025-kong-pricing.webp)](https://api7.ai/fr/blog/kong-konnect-pricing)

Technology

March 10, 2025

#### [Explication des derniers prix de Kong 2025 et meilleures alternatives à Kong](https://api7.ai/fr/blog/kong-konnect-pricing)

Découvrez une analyse approfondie des modèles de tarification de Kong Konnect pour 2025 et les meilleures alternatives à Kong pour la gestion d'API en entreprise.

[API Trends](https://api7.ai/tags/api-trends)

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

[![Gestion du cycle de vie des API : Stratégies clés pour réussir](https://static.api7.ai/uploads/2025/02/19/gsEjQi5A_api-lifecycle-management.png)](https://api7.ai/fr/blog/api-lifecycle-management-strategies)

Technology

February 19, 2025

#### [Gestion du cycle de vie des API : Stratégies clés pour réussir](https://api7.ai/fr/blog/api-lifecycle-management-strategies)

Discover essential strategies for effective API lifecycle management: enhance API security, scalability, and documentation.

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

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