vLLM: Menyiapkan vLLM Secara Lokal dan di Google Cloud untuk CPU

vLLM (Virtual Large Language Model) adalah pustaka yang dirancang untuk meng-host large language model (LLM). vLLM menyediakan lingkungan yang dioptimalkan untuk menangani tugas pemrosesan bahasa dalam skala besar.

Ada beberapa alasan mengapa kita mungkin ingin meng-host LLM sendiri. Meng-host model secara lokal atau di platform cloud memberi kita kendali atas privasi data, potensi kustomisasi model agar lebih sesuai dengan kebutuhan spesifik, dan dapat lebih murah tergantung aplikasinya.

Selain itu, vLLM kompatibel dengan OpenAI API. Kompatibilitas ini berarti jika kita memiliki kode yang sudah berinteraksi dengan infrastruktur OpenAI, kita dapat menggantinya dengan LLM yang kita host sendiri menggunakan vLLM tanpa harus mengubah basis kode yang ada.

Dalam artikel ini, saya akan memandu Anda menyiapkan vLLM. Kita akan mulai dengan menunjukkan cara menjalankannya di komputer menggunakan Docker, alat populer untuk kontainerisasi yang memudahkan menjalankan aplikasi secara konsisten di berbagai lingkungan. Lalu, kita akan mempelajari cara melakukan deployment vLLM di Google Cloud, memberikan solusi berskala untuk meng-host model tersebut agar siap menangani tugas yang lebih besar atau lalu lintas yang lebih tinggi.

Cara Menyiapkan vLLM Secara Lokal untuk CPU Dengan Docker

vLLM menyederhanakan menjalankan LLM dengan penyiapan efisien yang dioptimalkan untuk platform CUDA, yang biasanya berarti menggunakan GPU NVIDIA untuk akselerasi. Namun, jika kita ingin menjalankan model di CPU, kita dapat menggunakan image Docker yang disediakan vLLM khusus untuk penggunaan CPU. Fleksibilitas ini memungkinkan kita meng-host model meski tidak memiliki akses ke lingkungan berkemampuan CUDA. Untuk meng-host vLLM di platform CUDA, lihat panduan quickstart mereka.

Karena sebagian besar dari kita tidak memiliki akses ke GPU kelas atas, kita akan fokus menyiapkan vLLM untuk berjalan di CPU. Ini memastikan kita tetap bisa bereksperimen dengan LLM menggunakan sumber daya yang tersedia.

Untuk menyederhanakan proses, kita akan menggunakan Docker, alat populer yang memungkinkan kita mengemas aplikasi dan dependensinya ke dalam container. Anggap container sebagai unit portabel dan ringan yang berisi semua yang dibutuhkan untuk menjalankan perangkat lunak tertentu. Dengan Docker, kita tidak perlu repot memasang vLLM secara manual atau berurusan dengan potensi masalah kompatibilitas pada sistem kita.

vLLM menawarkan image Docker siap pakai yang dirancang khusus untuk eksekusi CPU. Image ini berisi semua komponen yang diperlukan untuk menjalankan vLLM, sehingga kita bisa fokus menggunakan model, bukan pada kerumitan penyiapannya. Artinya, kita dapat mulai menjalankan LLM dengan cepat dan efisien di CPU.

Langkah 1: Membangun image Docker

Pertama, kita perlu membangun image Docker yang memungkinkan kita menjalankan vLLM di komputer. Repositori vLLM menyediakan Dockerfile dengan semua instruksi yang diperlukan untuk membangun image yang dapat menjalankan vLLM di CPU.

• Dockerfile.cpu untuk CPU reguler.
• Dockerfile.arm untuk CPU ARM seperti pada Mac modern.

Karena saya menggunakan Mac dengan prosesor M2, saya akan menggunakan file .arm. Untuk membangun image, pertama-tama kita klon atau unduh repositori lalu jalankan perintah ini dari dalamnya:

docker build -f Dockerfile.arm -t vllm-cpu --shm-size=4g .

Berikut ringkasan cepat tentang apa yang dilakukan perintah ini:

• docker build: Perintah ini membuat image Docker dari Dockerfile.
• -f Dockerfile.arm: Menentukan Dockerfile yang akan digunakan.
• -t vllm-cpu: Memberi tag image sebagai vllm-cpu agar mudah dirujuk (bisa juga nama lain).
• --shm-size=4g: Mengalokasikan 4 gigabita memori bersama, yang membantu meningkatkan kinerja.

Langkah 2: Menyiapkan Hugging Face

vLLM menggunakan Hugging Face, sebuah platform untuk memfasilitasi pengelolaan model, guna mempermudah proses hosting model. Berikut cara memulainya:

1. Buat akun Hugging Face: Kunjungi situs Hugging Face dan daftar akun jika belum memiliki.
2. Minta akses ke model: Setelah masuk, cari model yang ingin digunakan. Untuk demonstrasi ini, saya merekomendasikan meta-llama/Llama-3.2-1B-Instruct, karena ukurannya lebih kecil dan cocok untuk pengujian awal. Pada halaman model, mungkin ada opsi untuk meminta akses. Ikuti instruksi yang diberikan untuk mendapatkan akses.
3. Buat token: Buka halaman token API di Hugging Face. Klik "Create New Token" dan buat token. Token ini diperlukan untuk mengakses dan mengunduh model.

Langkah 3: Menjalankan container Docker

Setelah image Docker dibuat dan token Hugging Face siap, kita dapat menjalankan model vLLM dengan perintah berikut:

docker run -it --rm -p 8000:8000 \
--env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>" \
vllm-cpu --model meta-llama/Llama-3.2-1B-Instruct \
--dtype float16

Mari kita uraikan perintah ini:

• docker run: Menjalankan container berdasarkan image Docker yang ditentukan.
• -it: Menjalankan container secara interaktif dengan akses terminal.
• --rm: Secara otomatis menghapus container saat dihentikan.
• -p 8000:8000: Memetakan port 8000 di container ke port 8000 di mesin kita, sehingga layanan tersedia secara lokal.
• --env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>": Menetapkan token Hugging Face sebagai variabel lingkungan, memungkinkan vLLM terhubung ke API Hugging Face. Ganti <replace_with_hf_token> dengan token sebenarnya yang kita buat.
• vllm-cpu: Menentukan nama image Docker yang kita buat sebelumnya.
• --model meta-llama/Llama-3.2-1B-Instruct: Menunjukkan model yang akan dijalankan.
• --dtype float16: Gunakan tipe data float16 karena model membutuhkannya saat berjalan di CPU.

Saat kita menjalankan perintah ini, server akan memerlukan waktu hingga siap karena perlu mengunduh LLM. Server siap ketika kita melihat output seperti berikut di terminal:

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Berinteraksi Dengan LLM

Salah satu keunggulan vLLM adalah kompatibilitasnya dengan OpenAI API. Ini berarti jika kita memiliki kode yang dirancang untuk berinteraksi dengan infrastruktur OpenAI, kita dapat dengan mudah menggunakan kode yang sama untuk berkomunikasi dengan model yang di-host melalui vLLM.

Kompatibilitas ini memungkinkan transisi mulus tanpa mengubah basis kode yang ada. Jadi, saat menyiapkan vLLM, kita dapat terus menggunakan alat dan perintah yang familier untuk berinteraksi dengan LLM, membuat proses integrasi efisien dan mudah digunakan.

Berikut contoh cara mengirim pesan ke server lokal yang berjalan di Docker:

from openai import OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8000/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)
models = client.models.list()
model = models.data[0].id
completion = client.chat.completions.create(
    model=model,
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello"},
    ]
)
print(completion.choices[0].message.content)

Perhatikan bahwa kita menggunakan kunci API "EMPTY" di atas. Ini adalah kunci bawaan. Kita bisa mewajibkan kunci untuk mengakses model dengan menentukannya menggunakan parameter --api-key. Contohnya:

docker run -it --rm -p 8000:8000 \
--env "HUGGING_FACE_HUB_TOKEN=<replace_with_hf_token>" \
vllm-cpu --model meta-llama/Llama-3.2-1B-Instruct \
--dtype float16 --api-key supersecretkey

Kemudian, dalam kasus ini, kita perlu mengganti kunci di bagian atas kode:

openai_api_key = "supersecretkey"

Cara Meng-host vLLM CPU di Google Cloud

Meng-host LLM di Google Cloud menggunakan vLLM dapat menjadi solusi untuk melakukan deployment LLM. Mari kita uraikan langkah-langkah yang disebutkan dan memperjelasnya.

Langkah 1: Akses Google Cloud Console

Pertama, kita perlu mengakses Google Cloud Console. Kita dapat melakukannya dengan menavigasi ke Google Cloud Console di peramban web. Jika kita belum memiliki akun Google, kita perlu membuatnya untuk menggunakan layanan Google Cloud.

Langkah 2: Buat proyek

Di Google Cloud Console, cari menu tarik-turun proyek di bagian atas layar dan pilih "New Project." 

Masukkan vllm-demo sebagai nama proyek, sehingga lebih mudah dikenali nanti.

Jika kita sudah memiliki akun Google Cloud, akun penagihan uji coba mungkin tidak tersedia. Dalam kasus ini, kita perlu membuat akun penagihan baru. Untuk melakukannya, buka bagian "Billing" dan ikuti langkah-langkah untuk memilih akun penagihan yang ada atau membuat yang baru.

Langkah 3: Aktifkan layanan Artifact Registry

Artifact Registry adalah layanan yang memungkinkan kita menyimpan dan mengelola image container. Kita menggunakannya untuk menyimpan image Docker yang akan kita gunakan untuk menjalankan vLLM. 

Di Cloud Console, cari "artifact" untuk membuka Artifact Registry.

Kemudian, aktifkan untuk proyek kita. Langkah ini diperlukan untuk menyimpan image Docker dari penyiapan vLLM kita.

Langkah 4: Buat repositori artefak

Sekarang, kita perlu membuat repositori artefak untuk menyimpan image container. Arahkan ke Artifact Registry dan klik "Create Repository." 

Beri nama repositori vllm-cpu dan pilih "Docker" sebagai format. Tentukan lokasi us-central1 untuk mengoptimalkan performa sesuai kebutuhan deployment. Konfigurasi lainnya dapat dibiarkan pada nilai default.

Langkah 5: Build dan push image Docker

Sama seperti pada mesin lokal, kita perlu membangun image Docker lalu mengunggahnya (push) ke repositori Google Cloud vllm-cpu. Kita akan melakukannya menggunakan cloud shell yang berada di pojok kanan atas.

.

Di terminal tersebut, klon repositori GitHub vLLM dengan perintah berikut untuk mengambil file yang diperlukan:

git clone https://github.com/vllm-project/vllm.git

Masuk ke direktori vLLM yang sudah diklon menggunakan terminal.

cd vllm

Bangun image Docker dengan perintah berikut, yang menggunakan Dockerfile yang disediakan dan dikonfigurasi untuk penggunaan CPU:

docker build \
-t us-central1-docker.pkg.dev/vllm-demo/vllm-cpu/vllm-openai:latest \
-f Dockerfile.cpu .

Setelah image Docker dibuat, push ke Artifact Repository kita. Tindakan ini mengunggah image agar bisa digunakan nanti oleh layanan Google Cloud:

docker push us-central1-docker.pkg.dev/vllm-demo/vllm-cpu/vllm-openai:latest

Langkah 6: Menyiapkan layanan di Cloud Run

Google Cloud Run memungkinkan deployment aplikasi terkontainer. Kita menggunakan layanan ini untuk mendeploy image yang baru saja kita buat. 

Ketik "cloud run" di bilah pencarian dan buka layanan “Cloud Run”.

Dari sana, klik tombol "Create Service":

Lalu ikuti langkah-langkah ini:

1. Pilih image container: Pilih image container yang sudah kita push sebelumnya.
2. Konfigurasikan port: Ubah port default menjadi 8000, yang digunakan oleh vLLM.
3. Tambahkan token Hugging Face: Di bagian "Variables & Secrets", tambahkan variabel baru bernama HUGGING_FACE_HUB_TOKEN dan tempel token kita di sini. Token ini memungkinkan vLLM mengakses model dari Hugging Face.
4. Argumen container: Di bagian command, sertakan argumen --model=meta-llama/Llama-3.2-1B untuk menentukan model yang diinginkan.
5. Alokasikan sumber daya: Atur memori menjadi 16 GiB dan tetapkan 4 CPU agar container memiliki sumber daya yang cukup untuk pemrosesan yang efisien.
6. Pengaturan instance: Untuk mengurangi waktu cold start, pertahankan setidaknya satu instance tetap aktif. Ini mungkin meningkatkan biaya tetapi meningkatkan performa dengan meminimalkan waktu unduh model dan spin-up.

Dengan semua konfigurasi telah diatur (opsi lain dapat dibiarkan pada nilai default), klik tombol “Create” di bagian bawah halaman. Tunggu hingga layanan siap dan buka halaman layanan tersebut. Di sana, kita memiliki URL layanan yang dapat digunakan untuk berkomunikasi dengan LLM. 

URL-nya akan terlihat seperti ini:

https://vllm-llama-577126904161.us-central1.run.app

Berinteraksi dengan LLM

Kita dapat berinteraksi dengan LLM menggunakan Python seperti saat menjalankan model secara lokal. Kita hanya perlu mengubah URL di skrip:

# Ganti dengan URL layanan Anda
openai_api_base = "https://vllm-llama-577126904161.us-central1.run.app/v1"

Pertimbangan biaya penting

Peringatan: Jika Anda mengikuti langkah-langkah ini, ingat bahwa menjaga artifact registry tetap aktif akan menimbulkan biaya. Jadi harap ingat untuk melepaskan tautan akun penagihan setelah mengikuti panduan ini, atau Anda akan ditagih meskipun tidak ada yang menggunakannya.

Penyiapan GPU Google Cloud

Pada saat penulisan tutorial ini, dukungan GPU untuk Google Cloud Run tersedia berdasarkan permintaan. Artinya kita perlu secara khusus meminta akses ke fitur ini. Setelah diberikan, menjalankan vLLM menggunakan GPU akan secara signifikan meningkatkan performanya dibandingkan penggunaan CPU. Ini sangat bermanfaat untuk menangani large language model, karena GPU dirancang untuk memproses tugas paralel dengan lebih efisien.

Jika kita mendapatkan akses ke dukungan GPU, kita dapat menyederhanakan alur kerja. Dalam skenario ini, kita tidak perlu membangun image Docker sendiri. Sebagai gantinya, kita dapat langsung membuat layanan menggunakan image yang sudah ada vllm/vllm-openai:latest. Image ini dioptimalkan untuk bekerja dengan GPU, memungkinkan kita mendeploy model dengan cepat dan efektif tanpa langkah penyiapan tambahan yang diperlukan untuk konfigurasi CPU.

Setelah akses GPU disetujui dan kita menyiapkan layanan menggunakan image yang disediakan, deployment vLLM kita dapat memanfaatkan sepenuhnya daya dan kecepatan yang ditawarkan GPU, sehingga cocok untuk aplikasi waktu nyata dan tugas pemrosesan bahasa dengan permintaan tinggi.

RunPod: Alternatif Hosting

Bagi yang mencari opsi hosting alternatif, platform seperti RunPod menawarkan layanan yang disederhanakan untuk meng-host large language model. RunPod, misalnya, menyediakan penyiapan serverless yang menyederhanakan proses deployment.

Meskipun opsi ini ramah pengguna dan cepat disiapkan, perlu diingat bahwa kemudahan sering kali datang dengan biaya yang lebih tinggi. Jika anggaran menjadi pertimbangan, kita mungkin perlu menimbang kemudahan penggunaan dibandingkan biaya yang terkait dengan layanan seperti ini.

Kesimpulan

Dalam tutorial ini, kita menelusuri proses menyiapkan dan meng-host vLLM baik secara lokal maupun di Google Cloud.

Kita mempelajari cara membangun dan menjalankan image Docker yang disesuaikan khusus untuk CPU, sehingga tetap dapat diakses meski tanpa sumber daya GPU kelas atas. Selain itu, kita meninjau deployment vLLM di Google Cloud, yang menyediakan solusi berskala untuk menangani tugas yang lebih besar.