Men-deploy Model Terbuka di GKE

1. Pengantar

Ringkasan

Tujuan lab ini adalah memberi Anda pengalaman langsung men-deploy model terbuka di Google Cloud, mulai dari penyiapan lokal sederhana hingga deployment tingkat produksi di Google Kubernetes Engine (GKE). Anda akan mempelajari cara menggunakan berbagai alat yang sesuai untuk setiap tahap siklus proses pengembangan.

Lab ini mengikuti jalur berikut:

  • Pembuatan Prototipe Cepat: Anda akan menjalankan model dengan Ollama secara lokal terlebih dahulu untuk melihat betapa mudahnya memulai.
  • Deployment Produksi: Terakhir, Anda akan men-deploy model ke GKE Autopilot menggunakan Ollama sebagai mesin penayangan yang skalabel.

Memahami Model Terbuka

Saat ini, orang-orang biasanya merujuk "model terbuka" sebagai model machine learning generatif yang tersedia secara publik untuk didownload dan digunakan oleh semua orang. Artinya, arsitektur model dan, yang paling penting, parameter atau "bobot" terlatihnya dirilis secara publik.

Transparansi ini menawarkan beberapa keunggulan dibandingkan model tertutup, yang biasanya hanya dapat diakses melalui API yang ketat:

  • Insight: Developer dan peneliti dapat melihat "di balik layar" untuk memahami cara kerja internal model.
  • Kustomisasi: Pengguna dapat menyesuaikan model untuk tugas tertentu melalui proses yang disebut penyesuaian.
  • Inovasi: Memungkinkan komunitas membangun aplikasi baru dan inovatif di atas model yang sudah ada dan canggih.

Kontribusi Google dan rangkaian model Gemma

Google telah menjadi kontributor mendasar dalam gerakan AI open source selama bertahun-tahun. Arsitektur Transformer revolusioner, yang diperkenalkan dalam makalah tahun 2017 berjudul "Attention Is All You Need", adalah dasar bagi hampir semua model bahasa besar modern. Hal ini diikuti dengan model terbuka penting seperti BERT, T5, dan Flan-T5 yang disesuaikan untuk mengikuti perintah, yang masing-masing mendorong batas-batas kemampuan yang mungkin dilakukan dan memicu riset dan pengembangan di seluruh dunia.

Berdasarkan sejarah panjang inovasi terbuka ini, Google memperkenalkan rangkaian model Gemma. Model Gemma dibuat dari riset dan teknologi yang sama dengan yang digunakan untuk model Gemini yang canggih dan tertutup, tetapi tersedia dengan bobot terbuka. Bagi pelanggan Google Cloud, hal ini memberikan kombinasi yang efektif antara teknologi canggih dan fleksibilitas open source, sehingga mereka dapat mengontrol siklus proses model, berintegrasi dengan ekosistem yang beragam, dan menerapkan strategi multi-cloud.

Sorotan pada Gemma 3

Dalam lab ini, kita akan berfokus pada Gemma 3, generasi terbaru dan tercanggih dalam rangkaian model ini. Model Gemma 3 ringan namun canggih, dirancang untuk berjalan secara efisien di satu GPU atau bahkan CPU.

  • Performa dan Ukuran: Model Gemma 3 ringan namun canggih, dirancang untuk berjalan secara efisien di GPU tunggal atau bahkan CPU. Model ini memberikan kualitas unggul dan performa tercanggih (SOTA) untuk ukurannya.
  • Modalitas: Model ini bersifat multimodal, mampu menangani input teks dan gambar untuk menghasilkan output teks.
  • Fitur Utama: Gemma 3 memiliki jendela konteks besar 128K dan mendukung lebih dari 140 bahasa.
  • Kasus Penggunaan: Model ini cocok untuk berbagai tugas, termasuk menjawab pertanyaan, meringkas, dan penalaran.

Terminologi utama

Saat bekerja dengan model terbuka, Anda akan menemukan beberapa istilah umum:

  • Prapelatihan melibatkan pelatihan model pada set data yang besar dan beragam untuk mempelajari pola bahasa umum. Model ini pada dasarnya adalah mesin pelengkapan otomatis yang canggih.
  • Penyesuaian instruksi menyesuaikan model terlatih untuk mengikuti petunjuk dan perintah tertentu dengan lebih baik. Model ini adalah model yang "tahu cara melakukan percakapan".
  • Varian Model: Model terbuka biasanya dirilis dalam berbagai ukuran (misalnya, Gemma 3 memiliki versi dan varian parameter 1B, 4B, 12B, dan 27B, seperti yang disesuaikan untuk mengikuti perintah (-it), terlatih, atau dikuantisasi untuk efisiensi.
  • Kebutuhan Resource: Model Bahasa Besar berukuran besar dan memerlukan resource komputasi yang signifikan untuk dihosting. Meskipun dapat dijalankan secara lokal, men-deploy-nya di cloud memberikan nilai yang signifikan, terutama saat dioptimalkan untuk performa dan skalabilitas dengan alat seperti Ollama.

Mengapa GKE untuk Inferensi Model Terbuka?

Lab ini memandu Anda dari eksekusi model lokal yang sederhana hingga deployment produksi skala penuh di Google Kubernetes Engine (GKE). Meskipun alat seperti Ollama sangat baik untuk pembuatan prototipe cepat, lingkungan produksi memiliki serangkaian persyaratan berat yang dapat dipenuhi secara unik oleh GKE.

Untuk aplikasi AI skala besar, Anda memerlukan lebih dari sekadar model yang berjalan; Anda memerlukan infrastruktur penayangan yang tangguh, skalabel, dan efisien. GKE menyediakan fondasi ini. Berikut waktu dan alasan Anda memilih GKE:

  • Pengelolaan yang Disederhanakan dengan Autopilot: GKE Autopilot mengelola infrastruktur dasar untuk Anda. Anda berfokus pada konfigurasi aplikasi, dan Autopilot akan menyediakan serta menskalakan node secara otomatis.
  • Performa & Skalabilitas Tinggi: Tangani traffic yang berat dan bervariasi dengan penskalaan otomatis GKE. Hal ini memastikan aplikasi Anda dapat memberikan throughput tinggi dengan latensi rendah, yang dapat ditingkatkan atau diturunkan skalanya sesuai kebutuhan.
  • Efektivitas Biaya dalam Skala Besar: Kelola resource secara efisien. GKE dapat menskalakan workload hingga nol untuk menghindari pembayaran resource yang tidak digunakan, dan Anda dapat memanfaatkan Spot VM untuk mengurangi biaya secara signifikan untuk workload inferensi stateless.
  • Portabilitas & Ekosistem yang Kaya: Hindari ketergantungan pada vendor dengan deployment berbasis Kubernetes yang portabel. GKE juga menyediakan akses ke ekosistem Cloud Native (CNCF) yang luas untuk alat pemantauan, logging, dan keamanan terbaik di kelasnya.

Singkatnya, Anda beralih ke GKE saat aplikasi AI Anda siap untuk produksi dan memerlukan platform yang dibangun untuk skala, performa, dan kematangan operasional yang serius.

Yang akan Anda pelajari

Di lab ini, Anda akan mempelajari cara melakukan tugas berikut:

  • Jalankan model terbuka secara lokal dengan Ollama.
  • Men-deploy model terbuka ke Autopilot Google Kubernetes Engine (GKE) dengan Ollama untuk penayangan.
  • Pahami progres dari framework pengembangan lokal ke arsitektur inferensi tingkat produksi di GKE.

2. Penyiapan project

Akun Google

Jika belum memiliki Akun Google pribadi, Anda harus membuat Akun Google.

Gunakan akun pribadi, bukan akun kantor atau sekolah.

Login ke Konsol Google Cloud

Login ke Konsol Google Cloud menggunakan Akun Google pribadi.

Aktifkan Penagihan

Menyiapkan akun penagihan pribadi

Jika menyiapkan penagihan menggunakan kredit Google Cloud, Anda dapat melewati langkah ini.

Untuk menyiapkan akun penagihan pribadi, buka di sini untuk mengaktifkan penagihan di Cloud Console.

Beberapa Catatan:

  • Menyelesaikan lab ini akan dikenai biaya kurang dari $1 USD untuk resource Cloud.
  • Anda dapat mengikuti langkah-langkah di akhir lab ini untuk menghapus resource agar tidak dikenai biaya lebih lanjut.
  • Pengguna baru memenuhi syarat untuk mengikuti Uji Coba Gratis senilai$300 USD.

Membuat project (opsional)

Jika Anda tidak memiliki project saat ini yang ingin digunakan untuk lab ini, buat project baru di sini.

3. Buka Cloud Shell Editor

  1. Klik link ini untuk langsung membuka Cloud Shell Editor
  2. Jika diminta untuk memberikan otorisasi kapan saja hari ini, klik Authorize untuk melanjutkan.Klik untuk memberikan otorisasi pada Cloud Shell
  3. Jika terminal tidak muncul di bagian bawah layar, buka terminal:
    • Klik Lihat
    • Klik TerminalMembuka terminal baru di Cloud Shell Editor
  4. Di terminal, tetapkan project Anda dengan perintah ini:
    gcloud config set project [PROJECT_ID]
    • Contoh:
      gcloud config set project lab-project-id-example
    • Jika tidak ingat project ID, Anda dapat mencantumkan semua project ID dengan:
      gcloud projects list
      Menetapkan project ID di terminal Cloud Shell Editor
  5. Anda akan melihat pesan ini:
    Updated property [core/project].

4. Menjalankan Gemma dengan Ollama

Tujuan pertama Anda adalah menjalankan Gemma 3 secepat mungkin di lingkungan pengembangan. Anda akan menggunakan Ollama, alat yang menyederhanakan secara signifikan cara menjalankan model bahasa besar secara lokal. Tugas ini menunjukkan cara paling mudah untuk mulai bereksperimen dengan model terbuka.

Ollama adalah alat open source gratis yang memungkinkan pengguna menjalankan model Generatif (model bahasa besar, model bahasa-visi, dan lainnya) secara lokal di komputer mereka sendiri. API ini menyederhanakan proses mengakses dan berinteraksi dengan model tersebut, sehingga model menjadi lebih mudah diakses dan memungkinkan pengguna bekerja dengan model tersebut secara pribadi.

Menginstal dan menjalankan Ollama

Sekarang, Anda siap menginstal Ollama, mendownload model Gemma 3, dan berinteraksi dengannya dari command line.

  1. Di terminal Cloud Shell, download dan instal Ollama:
    curl -fsSL https://ollama.com/install.sh | sh
    Perintah ini akan mendownload Ollama, menginstalnya, dan memulai layanan Ollama.
  2. Mulai layanan Ollama di latar belakang:
    ollama serve &
  3. Tarik (download) model Gemma 3 1B dengan Ollama:
    ollama pull gemma3:1b
  4. Jalankan model secara lokal:
    ollama run gemma3:1b
    Perintah ollama run menampilkan perintah (>>>) agar Anda dapat mengajukan pertanyaan kepada model.
  5. Uji model dengan pertanyaan. Misalnya, ketik Why is the sky blue?, lalu tekan ENTER. Anda akan melihat respons seperti berikut:
    >>> Why is the sky blue?
Okay, let's break down why the sky is blue – it's a fascinating phenomenon related to how light interacts with the Earth's atmosphere.
Here's the explanation:

**1. Sunlight and Colors:**

* Sunlight appears white, but it's actually made up of all the colors of the rainbow (red, orange, yellow, green, blue, indigo, and violet).
Think of a prism splitting sunlight.

**2. Rayleigh Scattering:**

* As sunlight enters the Earth's atmosphere...
...
  6. Untuk keluar dari perintah Ollama di Terminal, ketik /bye lalu tekan ENTER.

Menggunakan OpenAI SDK dengan Ollama

Setelah layanan Ollama berjalan, Anda dapat berinteraksi dengannya secara terprogram. Anda akan menggunakan OpenAI Python SDK, yang kompatibel dengan API yang diekspos Ollama.

  1. Di terminal Cloud Shell, buat dan aktifkan lingkungan virtual menggunakan uv. Tindakan ini memastikan dependensi project Anda tidak bertentangan dengan Python sistem.
    uv venv --python 3.14
source .venv/bin/activate
  2. Di terminal, instal OpenAI SDK:
    uv pip install openai
  3. Buat file baru bernama ollama_chat.py dengan memasukkan di terminal:
    cloudshell edit ollama_chat.py
  4. Tempelkan kode Python berikut ke ollama_chat.py. Kode ini mengirim permintaan ke server Ollama lokal.
    from openai import OpenAI

client = OpenAI(
    base_url = 'http://localhost:11434/v1',
    api_key='ollama', # required by OpenAI SDK, but not used by Ollama
)

response = client.chat.completions.create(
    model="gemma3:1b",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?"
        },
    ],
)
print(response.choices[0].message.content)
  5. Jalankan skrip di terminal Anda:
    python3 ollama_chat.py
    Setelah beberapa detik, Anda akan melihat respons yang mirip dengan yang Anda terima dari command line.
  6. Untuk mencoba mode streaming, buat file lain bernama ollama_stream.py dengan menjalankan perintah berikut di terminal:
    cloudshell edit ollama_stream.py
  7. Tempelkan konten berikut ke dalam file ollama_stream.py. Perhatikan parameter stream=True dalam permintaan. Hal ini memungkinkan model menampilkan token segera setelah dihasilkan.
    from openai import OpenAI

client = OpenAI(
    base_url = 'http://localhost:11434/v1',
    api_key='ollama',
)

stream = client.chat.completions.create(
    model="gemma3:1b",
    messages=[
        {
            "role": "user",
            "content": "Why is the sky blue?"
        },
    ],
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()
  8. Jalankan skrip streaming di terminal:
    python3 ollama_stream.py
    Respons akan muncul kata demi kata.

Streaming adalah fitur yang berguna untuk menciptakan pengalaman pengguna yang baik dalam aplikasi interaktif seperti chatbot. Daripada membuat pengguna menunggu seluruh jawaban dibuat, streaming menampilkan respons token demi token saat dibuat. Hal ini memberikan masukan langsung dan membuat aplikasi terasa jauh lebih responsif.

Yang Anda pelajari: Menjalankan Model Terbuka dengan Ollama

Anda telah berhasil menjalankan model terbuka menggunakan Ollama. Anda telah melihat betapa sederhananya mendownload model canggih seperti Gemma 3 dan berinteraksi dengannya, baik melalui antarmuka command line maupun secara terprogram dengan Python. Alur kerja ini ideal untuk pembuatan prototipe cepat dan pengembangan lokal. Sekarang Anda memiliki dasar yang kuat untuk menjelajahi opsi deployment yang lebih canggih.

5. Men-deploy Gemma dengan Ollama di GKE Autopilot

Untuk beban kerja produksi yang memerlukan operasi dan skalabilitas yang disederhanakan, Google Kubernetes Engine (GKE) adalah platform pilihan. Dalam tugas ini, Anda akan men-deploy Gemma menggunakan Ollama di cluster GKE Autopilot.

GKE Autopilot adalah mode operasi di GKE tempat Google mengelola konfigurasi cluster Anda, termasuk node, penskalaan, keamanan, dan setelan lainnya yang telah dikonfigurasi sebelumnya. Layanan ini menciptakan pengalaman Kubernetes yang benar-benar "serverless", yang sempurna untuk menjalankan beban kerja inferensi tanpa mengelola infrastruktur komputasi yang mendasarinya.

Menyiapkan lingkungan GKE

Untuk tugas terakhir dalam men-deploy ke Kubernetes, Anda akan menyediakan cluster Autopilot GKE.

  1. Di terminal Cloud Shell, tetapkan variabel lingkungan untuk project dan region yang diinginkan.
    export PROJECT_ID=$(gcloud config get-value project)
export REGION=europe-west1

gcloud config set compute/region $REGION
  2. Aktifkan GKE API untuk project Anda dengan menjalankan perintah berikut di terminal:
    gcloud services enable container.googleapis.com
  3. Buat cluster GKE Autopilot dengan menjalankan perintah berikut di terminal: 
    gcloud container clusters create-auto gemma-cluster \
  --region $REGION \
  --release-channel rapid
  4. Dapatkan kredensial untuk cluster baru Anda dengan menjalankan perintah berikut di terminal:
    gcloud container clusters get-credentials gemma-cluster \
  --region $REGION

Men-deploy Ollama dan Gemma

Setelah memiliki cluster GKE Autopilot, Anda dapat men-deploy server Ollama. Autopilot akan otomatis menyediakan resource komputasi (CPU dan Memori) berdasarkan persyaratan yang Anda tentukan dalam manifes deployment.

  1. Buat file baru bernama gemma-deployment.yaml dengan menjalankan perintah berikut di terminal:
    cloudshell edit gemma-deployment.yaml
  2. Tempel konfigurasi YAML berikut ke gemma-deployment.yaml. Konfigurasi ini menentukan deployment yang menggunakan image Ollama resmi untuk dijalankan di CPU.
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama-gemma
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama-gemma
  template:
    metadata:
      labels:
        app: ollama-gemma
    spec:
      containers:
      - name: ollama-gemma-container
        image: ollama/ollama:0.12.10
        resources:
          requests:
            cpu: "8"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
          limits:
            cpu: "8"
            memory: "8Gi"
            ephemeral-storage: "10Gi"
        # We use a script to start the server and pull the model
        command: ["/bin/bash", "-c"]
        args:
        - |
          ollama serve &
          OLLAMA_PID=$!
          echo "Waiting for Ollama server to start..."
          sleep 5
          echo "Pulling Gemma model..."
          ollama pull gemma3:1b
          echo "Model pulled. Ready to serve."
          wait $OLLAMA_PID
        ports:
        - containerPort: 11434
        env:
        - name: OLLAMA_HOST
          value: "0.0.0.0"
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: ollama-gemma
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 11434
    Berikut penjelasan konfigurasi untuk Autopilot:
    • image: ollama/ollama:latest: Ini menentukan image Docker Ollama resmi.
    • resources: Kita secara eksplisit meminta 8 vCPU dan memori 8 Gi. GKE Autopilot menggunakan nilai ini untuk menyediakan komputasi yang mendasarinya. Karena kita tidak menggunakan GPU, model akan berjalan di CPU. Memori 8 GiB sudah cukup untuk menampung model Gemma 1B dan konteksnya.
    • command/args: Kita mengganti perintah startup untuk memastikan model ditarik saat pod dimulai. Skrip memulai server di latar belakang, menunggu hingga server siap, menarik model gemma3:1b, lalu membuat server tetap berjalan.
    • OLLAMA_HOST: Menyetelnya ke 0.0.0.0 memastikan Ollama memproses semua antarmuka jaringan dalam container, sehingga dapat diakses oleh Layanan Kubernetes.
  3. Di terminal, terapkan manifes deployment ke cluster Anda:
    kubectl apply -f gemma-deployment.yaml
    Perlu waktu beberapa menit agar Autopilot menyediakan resource dan pod dimulai. Anda dapat memantaunya dengan:
    kubectl get pods --watch
    Tunggu hingga status pod adalah Running dan READY adalah 1/1 sebelum melanjutkan.

Menguji endpoint GKE

Layanan Ollama Anda kini berjalan di cluster GKE Autopilot. Untuk mengujinya dari terminal Cloud Shell, Anda akan menggunakan kubectl port-forward.

  1. Buka tab terminal Cloud Shell baru (klik ikon + di jendela terminal). Perintah port-forward adalah proses pemblokiran, sehingga memerlukan sesi terminalnya sendiri.
  2. Di terminal baru, jalankan perintah berikut untuk meneruskan port lokal (misalnya, 8000) ke port layanan (8000):
    kubectl port-forward service/llm-service 8000:8000
    Anda akan melihat output yang menunjukkan bahwa penerusan telah dimulai. Biarkan terminal ini tetap berjalan.
  3. Kembali ke terminal asli Anda.
  4. Kirim permintaan ke port lokal Anda 8000. Server Ollama mengekspos API yang kompatibel dengan OpenAI, dan karena penerusan port, Anda kini dapat mengaksesnya di http://127.0.0.1:8000.
    curl http://127.0.0.1:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "gemma3:1b",
"messages": [
{"role": "user", "content": "Explain why the sky is blue."}
]
}'
    Layanan akan menampilkan respons JSON dengan penyelesaian model.

6. Membersihkan

Agar tidak menimbulkan biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam lab ini, ikuti langkah-langkah berikut untuk menghapus cluster GKE.

  1. Di terminal Cloud Shell, hapus cluster GKE Autopilot:
    gcloud container clusters delete gemma-cluster \
  --region $REGION --quiet
    Perintah ini akan menghapus cluster dan semua resource terkait.

7. Kesimpulan

Bagus! Dalam lab ini, Anda telah mempelajari beberapa metode utama untuk men-deploy model terbuka di Google Cloud. Anda memulai dengan kesederhanaan dan kecepatan pengembangan lokal dengan Ollama. Terakhir, Anda men-deploy Gemma ke lingkungan yang skalabel dan siap produksi menggunakan Autopilot Google Kubernetes Engine dan framework Ollama.

Sekarang Anda telah memiliki pengetahuan untuk men-deploy model terbuka di Google Kubernetes Engine untuk workload yang menuntut dan dapat diskalakan tanpa mengelola infrastruktur yang mendasarinya.

Rekap

Di lab ini, Anda telah mempelajari:

  • Apa itu Model Terbuka dan mengapa Model Terbuka penting.
  • Cara menjalankan model terbuka secara lokal dengan Ollama.
  • Cara men-deploy model terbuka di Google Kubernetes Engine (GKE) Autopilot menggunakan Ollama untuk inferensi.

Pelajari lebih lanjut