GKE पर ओपन मॉडल डिप्लॉय करना

1. परिचय

खास जानकारी

इस लैब का मकसद, आपको Google Cloud पर ओपन मॉडल डिप्लॉय करने का व्यावहारिक अनुभव देना है. इसमें, आपको लोकल सेटअप से लेकर Google Kubernetes Engine (GKE) पर प्रोडक्शन-ग्रेड डिप्लॉयमेंट तक की प्रोसेस के बारे में बताया जाएगा. आपको डेवलपमेंट की लाइफ़साइकल के हर चरण के लिए सही टूल इस्तेमाल करने का तरीका बताया जाएगा.

लैब में इस पाथ का इस्तेमाल किया जाता है:

  • रैपिड प्रोटोटाइपिंग: सबसे पहले, Ollama के साथ स्थानीय तौर पर एक मॉडल चलाएं. इससे आपको यह पता चलेगा कि इसे इस्तेमाल करना कितना आसान है.
  • प्रोडक्शन डिप्लॉयमेंट: आखिर में, आपको मॉडल को GKE Autopilot पर डिप्लॉय करना होगा. इसके लिए, Ollama को स्केलेबल सर्विंग इंजन के तौर पर इस्तेमाल करें.

ओपन मॉडल के बारे में जानकारी

इन दिनों, "ओपन मॉडल" का मतलब आम तौर पर जनरेटिव मशीन लर्निंग मॉडल होता है, जो सार्वजनिक तौर पर उपलब्ध होता है. इसे कोई भी व्यक्ति डाउनलोड और इस्तेमाल कर सकता है. इसका मतलब है कि मॉडल के आर्किटेक्चर और सबसे अहम, इसके ट्रेन किए गए पैरामीटर या "वज़न" को सार्वजनिक तौर पर रिलीज़ किया जाता है.

पारदर्शी मॉडल के कई फ़ायदे हैं. वहीं, क्लोज़्ड मॉडल को आम तौर पर, सिर्फ़ पाबंदी वाले एपीआई के ज़रिए ऐक्सेस किया जा सकता है:

  • अहम जानकारी: डेवलपर और शोधकर्ता, मॉडल के काम करने के तरीके को समझने के लिए "अंदरूनी तौर पर" देख सकते हैं.
  • कस्टमाइज़ेशन: उपयोगकर्ता, फ़ाइन-ट्यूनिंग की प्रोसेस के ज़रिए मॉडल को खास टास्क के हिसाब से ढाल सकते हैं.
  • इनोवेशन: यह कम्यूनिटी को मौजूदा मॉडल के आधार पर, नए और इनोवेटिव ऐप्लिकेशन बनाने की सुविधा देता है.

Google का योगदान और Gemma फ़ैमिली

Google, ओपन-सोर्स एआई के विकास में कई सालों से अहम योगदान दे रहा है. साल 2017 में "Attention Is All You Need" पेपर में पेश किया गया क्रांतिकारी ट्रांसफ़ॉर्मर आर्किटेक्चर, आज के समय के लगभग सभी बड़े लैंग्वेज मॉडल का आधार है. इसके बाद, BERT, T5, और निर्देश के हिसाब से फ़ाइन-ट्यून किए गए Flan-T5 जैसे ओपन मॉडल लॉन्च किए गए. इन सभी ने, एआई की क्षमताओं को नई ऊंचाइयों पर पहुंचाया. साथ ही, दुनिया भर में रिसर्च और डेवलपमेंट को बढ़ावा दिया.

ओपन इनोवेशन के इस शानदार इतिहास को आगे बढ़ाते हुए, Google ने Gemma मॉडल फ़ैमिली लॉन्च की है. Gemma मॉडल, Gemini मॉडल में इस्तेमाल की गई रिसर्च और टेक्नोलॉजी का इस्तेमाल करके बनाए गए हैं. हालांकि, इन्हें ओपन वेट के साथ उपलब्ध कराया जाता है. Google Cloud के ग्राहकों के लिए, यह अत्याधुनिक टेक्नोलॉजी और ओपन सोर्स की सुविधा का बेहतरीन कॉम्बिनेशन है. इससे वे मॉडल के लाइफ़साइकल को कंट्रोल कर सकते हैं, अलग-अलग तरह के इकोसिस्टम के साथ इंटिग्रेट कर सकते हैं, और मल्टी-क्लाउड रणनीति अपना सकते हैं.

Gemma 3 पर स्पॉटलाइट

इस लैब में, हम Gemma 3 पर फ़ोकस करेंगे. यह इस फ़ैमिली का सबसे नया और सबसे बेहतर जनरेशन है. Gemma 3 मॉडल, लाइटवेट होने के साथ-साथ बेहतरीन भी हैं. इन्हें एक जीपीयू या सीपीयू पर आसानी से चलाने के लिए डिज़ाइन किया गया है.

  • परफ़ॉर्मेंस और साइज़: Gemma 3 मॉडल, लाइटवेट होने के साथ-साथ बेहतरीन भी हैं. इन्हें एक जीपीयू या सीपीयू पर भी आसानी से चलाने के लिए डिज़ाइन किया गया है. ये अपने साइज़ के हिसाब से, बेहतरीन क्वालिटी और सबसे बेहतर (एसओटीए) परफ़ॉर्मेंस देते हैं.
  • मोडेलिटी: ये मल्टी-मोडल होते हैं. ये टेक्स्ट और इमेज, दोनों तरह के इनपुट को प्रोसेस करके टेक्स्ट आउटपुट जनरेट कर सकते हैं.
  • मुख्य सुविधाएं: Gemma 3 में 128K कॉन्टेक्स्ट विंडो है. साथ ही, यह 140 से ज़्यादा भाषाओं में काम करता है.
  • इस्तेमाल के उदाहरण: ये मॉडल, कई तरह के टास्क के लिए सही हैं. जैसे, सवालों के जवाब देना, खास जानकारी देना, और तर्क देना.

मुख्य शब्दावली

ओपन मॉडल का इस्तेमाल करते समय, आपको कुछ सामान्य शब्दों के बारे में पता चलेगा:

  • प्री-ट्रेनिंग में, मॉडल को बड़े और अलग-अलग तरह के डेटासेट पर ट्रेन किया जाता है, ताकि वह भाषा के सामान्य पैटर्न सीख सके. ये मॉडल, असल में अपने-आप पूरा होने वाली सुविधा देने वाली मशीनें हैं.
  • निर्देशों के हिसाब से मॉडल को बेहतर बनाना: इससे पहले से ट्रेन किए गए मॉडल को बेहतर बनाया जाता है, ताकि वह खास निर्देशों और प्रॉम्प्ट को बेहतर तरीके से फ़ॉलो कर सके. ये ऐसे मॉडल हैं जो "चैट करना जानते हैं".
  • मॉडल के वैरिएंट: ओपन मॉडल आम तौर पर कई साइज़ में रिलीज़ किए जाते हैं. उदाहरण के लिए, Gemma 3 में 1B, 4B, 12B, और 27B पैरामीटर वर्शन हैं. साथ ही, इसमें अलग-अलग वैरिएंट भी हैं. जैसे, निर्देश के मुताबिक फ़ाइन-ट्यून किया गया (-it), पहले से ट्रेन किया गया या बेहतर परफ़ॉर्मेंस के लिए क्वांटाइज़ किया गया.
  • संसाधन की ज़रूरतें: लार्ज लैंग्वेज मॉडल बड़े होते हैं और इन्हें होस्ट करने के लिए, कंप्यूटिंग के ज़्यादा संसाधनों की ज़रूरत होती है. इन्हें स्थानीय तौर पर चलाया जा सकता है. हालांकि, क्लाउड में इन्हें डिप्लॉय करने से काफ़ी फ़ायदा मिलता है. खास तौर पर, जब इन्हें Ollama जैसे टूल की मदद से परफ़ॉर्मेंस और स्केलेबिलिटी के लिए ऑप्टिमाइज़ किया जाता है.

ओपन मॉडल को सर्व करने के लिए GKE का इस्तेमाल क्यों करें?

इस लैब में, आपको लोकल मॉडल को आसानी से लागू करने से लेकर Google Kubernetes Engine (GKE) पर बड़े पैमाने पर प्रोडक्शन डिप्लॉयमेंट करने तक की जानकारी मिलेगी. Ollama जैसे टूल, रैपिड प्रोटोटाइपिंग के लिए बेहतरीन हैं. हालांकि, प्रोडक्शन एनवायरमेंट के लिए कई ज़रूरी शर्तें होती हैं. GKE इन शर्तों को पूरा करने के लिए सबसे सही प्लैटफ़ॉर्म है.

एआई के बड़े ऐप्लिकेशन के लिए, आपको सिर्फ़ एक मॉडल की ज़रूरत नहीं होती. आपको एक ऐसा इन्फ़्रास्ट्रक्चर चाहिए जो भरोसेमंद हो, जिसे बढ़ाया जा सके, और जो बेहतर तरीके से काम करे. GKE यह सुविधा देता है. यहां बताया गया है कि आपको GKE कब और क्यों चुनना चाहिए:

  • Autopilot की मदद से आसानी से मैनेज करना: GKE Autopilot, आपके लिए बुनियादी ढांचे को मैनेज करता है. आपको सिर्फ़ अपने ऐप्लिकेशन के कॉन्फ़िगरेशन पर ध्यान देना होता है. Autopilot, नोड को अपने-आप उपलब्ध कराता है और उन्हें स्केल करता है.
  • बेहतर परफ़ॉर्मेंस और स्केलेबिलिटी: GKE की ऑटोमैटिक स्केलिंग की सुविधा की मदद से, मांग के हिसाब से अलग-अलग ट्रैफ़िक को मैनेज करें. इससे यह पक्का होता है कि आपका ऐप्लिकेशन कम समय में ज़्यादा डेटा प्रोसेस कर सकता है. साथ ही, ज़रूरत के हिसाब से इसे बढ़ाया या घटाया जा सकता है.
  • स्केल के हिसाब से लागत कम होना: संसाधनों को बेहतर तरीके से मैनेज करना. GKE, वर्कलोड को शून्य तक कम कर सकता है, ताकि इस्तेमाल न किए जा रहे संसाधनों के लिए पेमेंट न करना पड़े. साथ ही, स्पॉट वीएम का इस्तेमाल करके, बिना किसी स्टेटस वाले अनुमान वाले वर्कलोड की लागत को काफ़ी कम किया जा सकता है.
  • पोर्टेबिलिटी और बेहतर इकोसिस्टम: पोर्टेबल और Kubernetes पर आधारित डिप्लॉयमेंट की मदद से, वेंडर लॉक-इन से बचें. GKE, बेहतरीन मॉनिटरिंग, लॉगिंग, और सुरक्षा टूलिंग के लिए, Cloud Native (CNCF) के बड़े इकोसिस्टम का ऐक्सेस भी देता है.

संक्षेप में कहें, तो जब आपका एआई ऐप्लिकेशन प्रोडक्शन के लिए तैयार हो जाता है और उसे बड़े पैमाने पर इस्तेमाल करने, बेहतर परफ़ॉर्मेंस देने, और ऑपरेशनल मैच्योरिटी के लिए बनाए गए प्लैटफ़ॉर्म की ज़रूरत होती है, तब आपको GKE पर माइग्रेट करना चाहिए.

आपको क्या सीखने को मिलेगा

इस लैब में, आपको ये टास्क करने का तरीका बताया जाएगा:

  • Ollama की मदद से, ओपन मॉडल को स्थानीय तौर पर चलाएं.
  • ओलामा की मदद से, Google Kubernetes Engine (GKE) Autopilot पर ओपन मॉडल डिप्लॉय करें.
  • GKE पर लोकल डेवलपमेंट फ़्रेमवर्क से लेकर प्रोडक्शन-ग्रेड सर्विंग आर्किटेक्चर तक की प्रोसेस को समझें.

2. प्रोजेक्ट सेटअप करना

Google खाता

अगर आपके पास पहले से कोई निजी Google खाता नहीं है, तो आपको Google खाता बनाना होगा.

ऑफ़िस या स्कूल वाले खाते के बजाय, निजी खाते का इस्तेमाल करें.

Google Cloud Console में साइन इन करना

किसी निजी Google खाते का इस्तेमाल करके, Google Cloud Console में साइन इन करें.

बिलिंग चालू करें

निजी बिलिंग खाता सेट अप करना

अगर आपने Google Cloud क्रेडिट का इस्तेमाल करके बिलिंग सेट अप की है, तो इस चरण को छोड़ा जा सकता है.

निजी बिलिंग खाता सेट अप करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करने के लिए यहां जाएं.

ध्यान दें:

  • इस लैब को पूरा करने में, Cloud संसाधनों पर 1 डॉलर से कम का खर्च आना चाहिए.
  • ज़्यादा शुल्क से बचने के लिए, इस लैब के आखिर में दिए गए निर्देशों का पालन करके संसाधनों को मिटाया जा सकता है.
  • नए उपयोगकर्ता, 300 डॉलर के मुफ़्त में आज़माने की सुविधा का फ़ायदा पा सकते हैं.

प्रोजेक्ट बनाना (ज़रूरी नहीं)

अगर आपके पास कोई ऐसा मौजूदा प्रोजेक्ट नहीं है जिसका इस्तेमाल आपको इस लैब के लिए करना है, तो यहां नया प्रोजेक्ट बनाएं.

3. Cloud Shell Editor खोलें

  1. सीधे Cloud Shell Editor पर जाने के लिए, इस लिंक पर क्लिक करें
  2. अगर आज किसी भी समय अनुमति देने के लिए कहा जाता है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें.Cloud Shell को अनुमति देने के लिए क्लिक करें
  3. अगर टर्मिनल स्क्रीन पर सबसे नीचे नहीं दिखता है, तो इसे खोलें:
    • देखें पर क्लिक करें
    • टर्मिनलCloud Shell Editor में नया टर्मिनल खोलें पर क्लिक करें
  4. टर्मिनल में, इस कमांड का इस्तेमाल करके अपना प्रोजेक्ट सेट करें:
    gcloud config set project [PROJECT_ID]
    • उदाहरण:
      gcloud config set project lab-project-id-example
    • अगर आपको अपना प्रोजेक्ट आईडी याद नहीं है, तो इन कमांड का इस्तेमाल करके अपने सभी प्रोजेक्ट आईडी की सूची देखी जा सकती है:
      gcloud projects list
      Cloud Shell Editor के टर्मिनल में प्रोजेक्ट आईडी सेट करना
  5. आपको यह मैसेज दिखेगा:
    Updated property [core/project].

4. Ollama के साथ Gemma को चलाना

आपका पहला लक्ष्य, डेवलपमेंट एनवायरमेंट में Gemma 3 को जल्द से जल्द चालू करना है. आपको Ollama का इस्तेमाल करना होगा. यह एक ऐसा टूल है जो लार्ज लैंग्वेज मॉडल को स्थानीय तौर पर चलाने की प्रोसेस को काफ़ी आसान बना देता है. इस टास्क में, ओपन मॉडल को आज़माने का सबसे आसान तरीका बताया गया है.

Ollama एक मुफ़्त और ओपन-सोर्स टूल है. इसकी मदद से, उपयोगकर्ता जनरेटिव मॉडल (लार्ज लैंग्वेज मॉडल, विज़न-लैंग्वेज मॉडल वगैरह) को अपने कंप्यूटर पर स्थानीय तौर पर चला सकते हैं. इससे इन मॉडल को ऐक्सेस करना और इनके साथ इंटरैक्ट करना आसान हो जाता है. साथ ही, ये मॉडल ज़्यादा लोगों के लिए उपलब्ध हो जाते हैं. इससे उपयोगकर्ता, इन मॉडल के साथ निजी तौर पर काम कर पाते हैं.

Ollama को इंस्टॉल और रन करना

अब Ollama को इंस्टॉल किया जा सकता है. साथ ही, Gemma 3 मॉडल को डाउनलोड करके, कमांड लाइन से इसके साथ इंटरैक्ट किया जा सकता है.

  1. Cloud Shell टर्मिनल में, Ollama को डाउनलोड और इंस्टॉल करें:
    curl -fsSL https://ollama.com/install.sh | sh
    इस कमांड से Ollama डाउनलोड हो जाता है, इंस्टॉल हो जाता है, और Ollama सेवा शुरू हो जाती है.
  2. बैकग्राउंड में Ollama सेवा शुरू करें:
    ollama serve &
  3. Ollama की मदद से, Gemma 3 1B मॉडल को पुल (डाउनलोड) करें:
    ollama pull gemma3:1b
  4. मॉडल को स्थानीय तौर पर चलाएं:
    ollama run gemma3:1b
    ollama run कमांड से आपको एक प्रॉम्प्ट (>>>) मिलता है, ताकि आप मॉडल से सवाल पूछ सकें.
  5. किसी सवाल के साथ मॉडल को टेस्ट करें. उदाहरण के लिए, Why is the sky blue? टाइप करें और ENTER दबाएं. आपको कुछ ऐसा जवाब दिखेगा:
    >>> 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. टर्मिनल में Ollama प्रॉम्प्ट से बाहर निकलने के लिए, /bye टाइप करें और ENTER दबाएं.

Ollama के साथ OpenAI SDK का इस्तेमाल करना

Ollama सेवा चालू होने के बाद, प्रोग्राम के ज़रिए इससे इंटरैक्ट किया जा सकता है. आपको OpenAI Python SDK का इस्तेमाल करना होगा. यह Ollama के एपीआई के साथ काम करता है.

  1. Cloud Shell टर्मिनल में, uv का इस्तेमाल करके वर्चुअल एनवायरमेंट बनाएं और उसे चालू करें. इससे यह पक्का किया जाता है कि आपके प्रोजेक्ट की डिपेंडेंसी, सिस्टम Python के साथ काम करती हैं.
    uv venv --python 3.14
source .venv/bin/activate
  2. टर्मिनल में, OpenAI SDK टूल इंस्टॉल करें:
    uv pip install openai
  3. टर्मिनल में यह कमांड डालकर, ollama_chat.py नाम की नई फ़ाइल बनाएं:
    cloudshell edit ollama_chat.py
  4. नीचे दिए गए Python कोड को ollama_chat.py में चिपकाएं. यह कोड, लोकल Ollama सर्वर को अनुरोध भेजता है.
    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. अपने टर्मिनल में स्क्रिप्ट चलाएं:
    python3 ollama_chat.py
    कुछ सेकंड बाद, आपको कमांड लाइन से मिले जवाब जैसा ही जवाब दिखेगा.
  6. स्ट्रीमिंग मोड आज़माने के लिए, ollama_stream.py नाम की एक और फ़ाइल बनाएं. इसके लिए, टर्मिनल में यह कमांड चलाएं:
    cloudshell edit ollama_stream.py
  7. नीचे दिए गए कॉन्टेंट को ollama_stream.py फ़ाइल में चिपकाएं. अनुरोध में stream=True पैरामीटर पर ध्यान दें. इससे मॉडल को टोकन जनरेट होते ही उन्हें वापस भेजने की अनुमति मिलती है.
    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. टर्मिनल में स्ट्रीमिंग स्क्रिप्ट चलाएं:
    python3 ollama_stream.py
    अब जवाब, टोकन के हिसाब से दिखेगा.

स्ट्रीमिंग, चैटबॉट जैसे इंटरैक्टिव ऐप्लिकेशन में उपयोगकर्ताओं को बेहतर अनुभव देने के लिए एक मददगार सुविधा है. स्ट्रीमिंग की सुविधा की मदद से, जवाब जनरेट होने के दौरान ही उपयोगकर्ता को टोकन-दर-टोकन जवाब दिखाया जाता है. इससे उपयोगकर्ता को पूरे जवाब के जनरेट होने का इंतज़ार नहीं करना पड़ता. इससे तुरंत फ़ीडबैक मिलता है और ऐप्लिकेशन ज़्यादा तेज़ी से काम करता है.

आपने क्या सीखा: Ollama की मदद से ओपन मॉडल चलाना

आपने Ollama का इस्तेमाल करके, ओपन मॉडल को सफलतापूर्वक चलाया है. आपने देखा कि Gemma 3 जैसे दमदार मॉडल को डाउनलोड करना और उसके साथ इंटरैक्ट करना कितना आसान है. इसके लिए, कमांड-लाइन इंटरफ़ेस और Python, दोनों का इस्तेमाल किया जा सकता है. यह वर्कफ़्लो, रैपिड प्रोटोटाइपिंग और लोकल डेवलपमेंट के लिए सबसे सही है. अब आपके पास, डिप्लॉयमेंट के ज़्यादा बेहतर विकल्पों को एक्सप्लोर करने के लिए एक मज़बूत आधार है.

5. GKE Autopilot पर Ollama के साथ Gemma को डिप्लॉय करना

अगर आपको प्रोडक्शन वर्कलोड के लिए, आसान ऑपरेशन और स्केलेबिलिटी की ज़रूरत है, तो Google Kubernetes Engine (GKE) सबसे अच्छा प्लैटफ़ॉर्म है. इस टास्क में, आपको GKE Autopilot क्लस्टर पर Ollama का इस्तेमाल करके Gemma को डिप्लॉय करना होगा.

GKE Autopilot, GKE में काम करने का एक मोड है. इसमें Google, आपके क्लस्टर कॉन्फ़िगरेशन को मैनेज करता है. इसमें आपके नोड, स्केलिंग, सुरक्षा, और पहले से कॉन्फ़िगर की गई अन्य सेटिंग शामिल हैं. यह Kubernetes का "बिना सर्वर वाला" अनुभव देता है. यह कंप्यूट इंफ़्रास्ट्रक्चर को मैनेज किए बिना, अनुमान लगाने से जुड़े वर्कलोड को चलाने के लिए सबसे सही है.

GKE एनवायरमेंट तैयार करना

Kubernetes पर डिप्लॉय करने के आखिरी टास्क के लिए, आपको GKE Autopilot क्लस्टर उपलब्ध कराना होगा.

  1. Cloud Shell टर्मिनल में, अपने प्रोजेक्ट और पसंद के क्षेत्र के लिए एनवायरमेंट वैरिएबल सेट करें.
    export PROJECT_ID=$(gcloud config get-value project)
export REGION=europe-west1

gcloud config set compute/region $REGION
  2. अपने प्रोजेक्ट के लिए GKE API चालू करें. इसके लिए, टर्मिनल में यह कमांड चलाएं:
    gcloud services enable container.googleapis.com
  3. टर्मिनल में यह कमांड चलाकर, GKE Autopilot क्लस्टर बनाएं: 
    gcloud container clusters create-auto gemma-cluster \
  --region $REGION \
  --release-channel rapid
  4. टर्मिनल में यह कमांड चलाकर, अपने नए क्लस्टर के लिए क्रेडेंशियल पाएं:
    gcloud container clusters get-credentials gemma-cluster \
  --region $REGION

Ollama और Gemma को डिप्लॉय करना

अब आपके पास GKE Autopilot क्लस्टर है. इसलिए, Ollama सर्वर को डिप्लॉय किया जा सकता है. ऑटोपायलट, आपके डिप्लॉयमेंट मेनिफ़ेस्ट में तय की गई ज़रूरी शर्तों के आधार पर, कंप्यूट रिसॉर्स (सीपीयू और मेमोरी) अपने-आप उपलब्ध कराएगा.

  1. टर्मिनल में यह कमांड चलाकर, gemma-deployment.yaml नाम की नई फ़ाइल बनाएं:
    cloudshell edit gemma-deployment.yaml
  2. यहां दिए गए YAML कॉन्फ़िगरेशन को gemma-deployment.yaml में चिपकाएं. इस कॉन्फ़िगरेशन में, सीपीयू पर चलाने के लिए, Ollama की आधिकारिक इमेज का इस्तेमाल करने वाले डिप्लॉयमेंट के बारे में बताया गया है.
    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
    ऑटोपायलट के कॉन्फ़िगरेशन के बारे में यहां बताया गया है:
    • image: ollama/ollama:latest: इससे Ollama की आधिकारिक Docker इमेज के बारे में पता चलता है.
    • resources: हमने साफ़ तौर पर आठ वीसीपीयू और आठ जीबी मेमोरी का अनुरोध किया है. GKE Autopilot, इन वैल्यू का इस्तेमाल करके कंप्यूट की सुविधा देता है. हम GPU का इस्तेमाल नहीं कर रहे हैं. इसलिए, मॉडल सीपीयू पर चलेगा. Gemma 1B मॉडल और उसके कॉन्टेक्स्ट को सेव करने के लिए, 8Gi की मेमोरी काफ़ी है.
    • command/args: हम स्टार्टअप कमांड को बदल देते हैं, ताकि पॉड शुरू होने पर मॉडल को पुल किया जा सके. यह स्क्रिप्ट, सर्वर को बैकग्राउंड में शुरू करती है. इसके बाद, सर्वर के तैयार होने का इंतज़ार करती है. इसके बाद, gemma3:1b मॉडल को पुल करती है और फिर सर्वर को चालू रखती है.
    • OLLAMA_HOST: इसे 0.0.0.0 पर सेट करने से यह पक्का होता है कि Ollama, कंटेनर में सभी नेटवर्क इंटरफ़ेस पर काम करता है. इससे Kubernetes सेवा के लिए, Ollama को ऐक्सेस करना आसान हो जाता है.
  3. टर्मिनल में, अपने क्लस्टर पर डिप्लॉयमेंट मेनिफ़ेस्ट लागू करें:
    kubectl apply -f gemma-deployment.yaml
    Autopilot को संसाधनों को उपलब्ध कराने और पॉड को शुरू करने में कुछ मिनट लगेंगे. इसे इन तरीकों से मॉनिटर किया जा सकता है:
    kubectl get pods --watch
    आगे बढ़ने से पहले, इंतज़ार करें कि पॉड की स्थिति Running और READY की स्थिति 1/1 हो जाए.

GKE एंडपॉइंट की जांच करना

Ollama सेवा अब आपके GKE Autopilot क्लस्टर पर चल रही है. इसे अपने Cloud Shell टर्मिनल से टेस्ट करने के लिए, आपको kubectl port-forward का इस्तेमाल करना होगा.

  1. नया Cloud Shell टर्मिनल टैब खोलें. इसके लिए, टर्मिनल विंडो में मौजूद + आइकॉन पर क्लिक करें. port-forward कमांड एक ब्लॉकिंग प्रोसेस है. इसलिए, इसके लिए अलग टर्मिनल सेशन की ज़रूरत होती है.
  2. नए टर्मिनल में, लोकल पोर्ट (जैसे, 8000) से सेवा के पोर्ट (8000) तक:
    kubectl port-forward service/llm-service 8000:8000
    आपको आउटपुट दिखेगा, जिसमें बताया गया होगा कि फ़ॉरवर्ड करने की सुविधा शुरू हो गई है. इस टर्मिनल को चालू रहने दें.
  3. अपने ओरिजनल टर्मिनल पर वापस जाएं.
  4. अपने स्थानीय पोर्ट 8000 को अनुरोध भेजें. Ollama सर्वर, OpenAI के साथ काम करने वाला एपीआई उपलब्ध कराता है. पोर्ट फ़ॉरवर्ड करने की वजह से, अब इसे 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."}
]
}'
    यह सेवा, मॉडल के जवाब के साथ JSON रिस्पॉन्स देगी.

6. मिटाना

इस लैब में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud खाते से शुल्क न लिए जाने के लिए, GKE क्लस्टर को मिटाएं. इसके लिए, यह तरीका अपनाएं.

  1. Cloud Shell टर्मिनल में, GKE Autopilot क्लस्टर मिटाएं:
    gcloud container clusters delete gemma-cluster \
  --region $REGION --quiet
    इस कमांड से क्लस्टर और उससे जुड़े सभी संसाधन हटा दिए जाएंगे.

7. नतीजा

बहुत बढ़िया! इस लैब में, आपने Google Cloud पर ओपन मॉडल को डिप्लॉय करने के कई मुख्य तरीकों के बारे में जाना. आपने Ollama की मदद से, लोकल डेवलपमेंट को आसान और तेज़ बना दिया. आखिर में, आपने Google Kubernetes Engine Autopilot और Ollama फ़्रेमवर्क का इस्तेमाल करके, Gemma को प्रोडक्शन-ग्रेड और स्केलेबल एनवायरमेंट में डिप्लॉय किया.

अब आपके पास, Google Kubernetes Engine पर ओपन मॉडल डिप्लॉय करने की जानकारी है. इससे, मांग के हिसाब से और बड़े पैमाने पर किए जाने वाले वर्कलोड को मैनेज किया जा सकता है. इसके लिए, आपको बुनियादी इन्फ़्रास्ट्रक्चर को मैनेज करने की ज़रूरत नहीं होगी.

रीकैप

इस लैब में, आपने इनके बारे में सीखा:

  • ओपन मॉडल क्या होते हैं और ये क्यों ज़रूरी हैं.
  • Ollama की मदद से, ओपन मॉडल को स्थानीय तौर पर कैसे चलाया जाता है.
  • Google Kubernetes Engine (GKE) Autopilot पर, अनुमान लगाने के लिए Ollama का इस्तेमाल करके ओपन मॉडल को कैसे डिप्लॉय करें.

ज़्यादा जानें