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 पर डिप्लॉय करें, ताकि Ollama की मदद से उसे इस्तेमाल किया जा सके.
  • 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: हम साफ़ तौर पर 8 vCPU और 8Gi मेमोरी का अनुरोध करते हैं. 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
    ऑटोपायलट को संसाधनों को उपलब्ध कराने और पॉड को शुरू करने में कुछ मिनट लगेंगे. इसे इन तरीकों से मॉनिटर किया जा सकता है:
    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 की मदद से, ओपन मॉडल को स्थानीय तौर पर कैसे चलाया जा सकता है.
  • Ollama का इस्तेमाल करके, अनुमान लगाने के लिए Google Kubernetes Engine (GKE) Autopilot पर ओपन मॉडल को डिप्लॉय करने का तरीका.

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