Mengelola Aplikasi Java Berbasis AI dengan API Management

Bobur Umurzokov

Bobur Umurzokov

June 22, 2023

Technology

Dalam artikel ini, kita akan menjelajahi cara mengintegrasikan OpenAI's ChatGPT API dengan aplikasi Spring Boot dan mengelola API menggunakan Apache APISIX, sebuah API gateway open-source. Integrasi ini akan memungkinkan kita untuk memanfaatkan kekuatan ChatGPT, model bahasa mutakhir yang dikembangkan oleh OpenAI, dalam aplikasi Spring Boot kita, sementara APISIX akan menyediakan cara yang kuat, skalabel, dan aman untuk mengelola API.

OpenAI ChatGPT APIs

OpenAI's ChatGPT API adalah alat yang kuat yang dapat kita gunakan untuk mengintegrasikan kemampuan model ChatGPT ke dalam aplikasi atau layanan kita sendiri. API ini memungkinkan kita untuk mengirim serangkaian pesan dan menerima pesan yang dihasilkan oleh model AI sebagai respons melalui REST. API ini menawarkan berbagai API untuk membuat respons teks dalam chatbot, penyelesaian kode, menghasilkan gambar, atau menjawab pertanyaan dalam antarmuka percakapan. Dalam tutorial ini, kita akan menggunakan chat completion API untuk menghasilkan respons terhadap sebuah prompt (pada dasarnya kita bisa bertanya apa saja). Sebelum memulai tutorial, Anda dapat menjelajahi API untuk memahami cara mengautentikasi ke API menggunakan kunci API, bagaimana parameter permintaan API dan respons terlihat.

Contoh permintaan cURL ke chat completion API akan terlihat seperti ini. Anda mengganti OPENAI_API_KEY dengan kunci API Anda sendiri dan menempatkannya di header Authorization saat memanggil 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?"}]
}'

Berikut adalah contoh respons 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 adalah gateway API dinamis, real-time, dan berkinerja tinggi yang dirancang untuk memfasilitasi manajemen dan routing microservices dan API. Ini menyediakan fitur seperti load balancing, rate limiting, autentikasi, otorisasi, dan kontrol lalu lintas, yang semuanya membantu menyederhanakan manajemen microservices dan API. Apache APISIX dibangun di atas server Nginx dan dapat mendukung tingkat lalu lintas yang tinggi dengan latensi rendah dan ketersediaan tinggi. Ini adalah open source dan dirilis di bawah lisensi Apache 2.0."
      },
      "finish_reason": "stop",
      "index": 0
    }
  ]
}

Contoh kode proyek

Tutorial ini terdiri dari dua bagian. Bagian pertama mencakup penyiapan aplikasi Spring Boot dan pembuatan endpoint API baru yang dapat menangani panggilan API kita ke chat completion API secara terprogram. Pada bagian kedua, kita akan memperkenalkan fitur APISIX seperti keamanan dan kontrol lalu lintas ke API Spring Boot. Contoh kode lengkap untuk tutorial ini tersedia di repositori GitHub bernama apisix-java-chatgpt-openaiapi.

Prasyarat

Sebelum memulai, pastikan Anda memiliki hal berikut:

  • Buat OpenAI API Key: Untuk mengakses OpenAI API, Anda perlu membuat API Key. Anda dapat melakukannya dengan masuk ke situs web OpenAI dan menavigasi ke halaman manajemen API Key.
  • Docker terinstal di mesin Anda untuk menjalankan APISIX dan Spring Boot.

Langkah 1: Menyiapkan aplikasi Spring Boot Anda

Pertama, kita perlu menyiapkan aplikasi Spring Boot baru. Anda dapat menggunakan Spring Initializr untuk menghasilkan proyek Maven baru dengan dependensi yang diperlukan. Untuk tutorial ini, kita akan membutuhkan dependensi Spring Boot Starter Web. Untuk mengintegrasikan ChatGPT API, kita akan menggunakan klien Java OpenAI. Ada library komunitas open-source bernama https://github.com/TheoKanning/openai-java. Ini menyediakan kelas layanan yang membuat dan memanggil klien API GPT OpenAI dalam Java. Tentu saja, Anda juga dapat menulis implementasi sendiri di Spring yang berinteraksi dengan API OpenAI. Lihat library klien lainnya untuk bahasa pemrograman yang berbeda.

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

Langkah 2: Membuat kelas Controller

Di kelas ChatCompletionController.java, Anda dapat menggunakan layanan OpenAI untuk mengirim permintaan ke ChatGPT API.

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();
    }
}

Endpoint API Chat /ai-chat menangani permintaan POST, membuat permintaan chat, dan mengirimkannya ke API OpenAI. Kemudian, mengembalikan pesan pertama dari respons API.

Langkah 3: Menentukan properti aplikasi

Selanjutnya, kita menyediakan properti untuk API seperti model dan API key di file application.properties:

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

Langkah 4: Menjalankan aplikasi Spring Boot

Kita sekarang dapat menjalankan Application.java dan mengujinya dengan Postman atau perintah cURL.

Respons AI dari Spring Boot

Seperti yang bisa kita lihat, aplikasi menghasilkan respons terhadap pertanyaan kita dalam badan permintaan prompt.

Langkah 5: Membuat Dockerfile

Kita menggunakan kontainer Docker untuk membungkus aplikasi Spring Boot kita dan menggunakannya bersama dengan kontainer APISIX lainnya di docker-compose.yml. Untuk melakukannya, kita dapat membuat Dockerfile untuk membangun JAR dan mengeksekusinya. Lihat tutorial dockerize Spring Boot app. Kemudian, daftarkan layanan di file docker compose yaml.

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

Langkah 6: Menyiapkan Apache APISIX

Untuk menyiapkan APISIX, kita dapat menjalankan perintah docker compose up. Karena kita sudah mendefinisikan semua layanan yang diperlukan di docker-compose.yml. File ini hanya mendefinisikan 2 kontainer, satu untuk APISIX, dan satu lagi untuk aplikasi Spring boot yang kita implementasikan pada langkah sebelumnya. Dalam proyek sampel ini, kita menjalankan APISIX dalam mode standalone. Ada opsi instalasi APISIX dan mode deployment lainnya juga. Sekarang APISIX sebagai layanan terpisah berjalan di localhost:9080 dan aplikasi Spring Boot di localhost:8080

Langkah 7: Mengamankan API dengan APISIX

Setelah APISIX disiapkan, kita dapat menambahkan fitur keamanan ke API Spring boot kita yang sudah ada /ai-chat sehingga hanya konsumen API yang diizinkan yang dapat mengakses API ini. APISIX menyediakan beberapa plugin untuk mengamankan API Anda. Misalnya, Anda dapat menggunakan plugin jwt-auth untuk memerlukan token JWT untuk semua permintaan. Berikut adalah contoh cara menambahkan rute dengan upstream dan plugin menggunakan file 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

Setelah kita menentukan upstreams, routes, dan objek konsumen serta aturan routing dalam konfigurasi APISIX, file konfigurasi akan dimuat ke memori segera setelah layanan node APISIX dimulai di Docker. Apisix secara berkala mencoba mendeteksi apakah konten file diperbarui, jika ada pembaruan, ia secara otomatis memuat ulang perubahan.

Dengan konfigurasi ini, kita menambahkan satu upstream, dua rute, dan satu objek konsumen. Di rute pertama, semua permintaan ke /ask-me-anything (yang merupakan jalur URI kustom, Anda dapat menentukan URI apa pun di sana) harus menyertakan Authorization: JWT_TOKEN di header. Kemudian, APISIX menulis ulang jalur URI kustom ke API aktual /ai-chat secara otomatis dengan bantuan plugin proxy-rewrite dan meneruskan permintaan ke aplikasi Spring Boot yang berjalan di localhost:8080.

Jika Anda mencoba meminta rute APISIX, itu akan menolak permintaan kita dengan mengembalikan kesalahan yang diotorisasi:

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

Hasil dari permintaan di atas:

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

Dalam konfigurasi rute kedua, kita mengaktifkan plugin public-api untuk mengekspos endpoint baru /login untuk menandatangani token JWT baru. Karena APISIX dapat bertindak sebagai penyedia identitas untuk menghasilkan dan memvalidasi token baru dari konsumen API atau aplikasi klien. Lihat Langkah 8, bagaimana kita mengklaim token baru untuk konsumen API kita.

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

Jika Anda perhatikan dalam file konfigurasi yang sama, kita mendaftarkan konsumen API untuk menggunakan API bertenaga AI /ask-me-anything dan pengguna kita dapat mengklaim APISIX menggunakan rahasia mereka untuk menghasilkan token JWT untuk mengakses API:

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

Langkah 8: Mengklaim token JWT baru

Sekarang kita dapat mengklaim token JWT baru untuk konsumen API kita yang ada dengan kunci:

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

Kita akan mendapatkan token baru sebagai respons dari APISIX:

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

Langkah 9: Meminta API dengan token JWT

Akhirnya, kita dapat mengirim permintaan ke API /ask-me-anything dengan token JWT di header yang kita dapatkan pada langkah sebelumnya.

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

Atau menggunakan Postman, kita akan mendapatkan respons AI tetapi kali ini respons datang melalui Gateway APISIX:

Respons AI dari APISIX

Kesimpulan

Dalam tutorial ini, kita menjelajahi OpenAI ChatGPT API untuk menghasilkan respons terhadap prompt. Kita membuat aplikasi Spring Boot yang memanggil API untuk menghasilkan respons terhadap prompt. Selanjutnya, Anda dapat memperkenalkan fitur tambahan ke integrasi Anda dengan memperbarui file apisix.yml yang ada. Juga, Anda dapat memeriksa cabang bernama with-frontend dan menjalankan proyek untuk melihat antarmuka UI yang dibangun menggunakan Appsmith yang bekerja dengan APISIX.

Sumber daya terkait

Konten yang direkomendasikan

Tags:
Java
Spring Boot Web API
Managing Java APIs
API Gateway for ChatGPT