פריסת מודלים פתוחים ב-GKE

1. מבוא

סקירה כללית

מטרת ה-Lab הזה היא לספק לכם ניסיון מעשי בפריסת מודל פתוח ב-Google Cloud, החל מהגדרה מקומית פשוטה ועד לפריסה ברמת ייצור ב-Google Kubernetes Engine‏ (GKE). תלמדו איך להשתמש בכלים שונים שמתאימים לכל שלב במחזור החיים של הפיתוח.

השיעור הזה מתבסס על השלבים הבאים:

  • יצירת אב טיפוס מהיר: קודם תריצו מודל עם Ollama באופן מקומי כדי לראות כמה קל להתחיל.
  • פריסה בסביבת ייצור: לבסוף, תפרסו את המודל ב-GKE Autopilot באמצעות Ollama כמנוע שניתן להרחבה להצגת תוצאות.

הסבר על מודלים פתוחים

המונח 'מודל פתוח' מתייחס בדרך כלל למודל גנרטיבי של למידת מכונה שזמין לציבור הרחב להורדה ולשימוש. כלומר, הארכיטקטורה של המודל, ומה שהכי חשוב, הפרמטרים המאומנים או 'המשקלים' שלו, מתפרסמים לציבור.

השקיפות הזו מציעה כמה יתרונות לעומת מודלים סגורים, שבדרך כלל אפשר לגשת אליהם רק דרך API מגביל:

  • תובנה: מפתחים וחוקרים יכולים לבדוק את המנגנונים הפנימיים של המודל.
  • התאמה אישית: משתמשים יכולים להתאים את המודל למשימות ספציפיות באמצעות תהליך שנקרא כוונון עדין.
  • חדשנות: היא מאפשרת לקהילה לבנות אפליקציות חדשות וחדשניות על בסיס מודלים קיימים ועוצמתיים.

התרומה של Google ומשפחת Gemma

‫Google תורמת באופן משמעותי לתנועת ה-AI בקוד פתוח כבר הרבה שנים. ארכיטקטורת הטרנספורמרים המהפכנית, שהוצגה במאמר "Attention Is All You Need" משנת 2017, היא הבסיס לרוב המודלים המודרניים של שפה גדולה (LLM). אחריו הגיעו מודלים פורצי דרך כמו BERT,‏ T5 ו-Flan-T5 שעברו כוונון להוראות, וכל אחד מהם הרחיב את גבולות האפשרויות והניע מחקר ופיתוח ברחבי העולם.

על בסיס ההיסטוריה העשירה הזו של חדשנות פתוחה, Google הציגה את משפחת המודלים Gemma. מודלים של Gemma נוצרים מאותם מחקרים וטכנולוגיות שמשמשים ליצירת מודלים רבי-עוצמה של Gemini עם קוד סגור, אבל הם זמינים עם משקלים פתוחים. לקוחות Google Cloud נהנים משילוב עוצמתי של טכנולוגיה מתקדמת וגמישות של קוד פתוח, שמאפשר להם לשלוט במחזור החיים של המודל, להשתלב עם מערכת אקולוגית מגוונת וליישם אסטרטגיית מולטי-קלאוד.

זרקור על Gemma 3

בשיעור ה-Lab הזה נתמקד ב-Gemma 3, הדור החדש והמתקדם ביותר במשפחה הזו. מודלים של Gemma 3 הם קלי משקל אבל מתקדמים, והם מיועדים לפעול ביעילות במעבד גרפי יחיד או אפילו במעבד מרכזי.

  • ביצועים וגודל: מודלים של Gemma 3 הם קלי משקל אבל מתקדמים, והם מיועדים לפעול ביעילות ב-GPU יחיד או אפילו במעבד. הם מספקים איכות מעולה וביצועים מתקדמים (SOTA) ביחס לגודל שלהם.
  • מודאליות: הם מולטי-מודאליים, כלומר יכולים לעבד קלט של טקסט ותמונות כדי ליצור פלט של טקסט.
  • תכונות עיקריות: ל-Gemma 3 יש חלון הקשר גדול של 128K והיא תומכת ביותר מ-140 שפות.
  • תרחישי שימוש: המודלים האלה מתאימים למגוון משימות, כולל מענה לשאלות, סיכום והסקת מסקנות.

מונחים חשובים

במהלך העבודה עם מודלים פתוחים, תיתקלו בכמה מונחים נפוצים:

  • אימון מראש כולל אימון של מודל על מערך נתונים עצום ומגוון כדי ללמוד דפוסי שפה כלליים. המודלים האלה הם בעצם מכונות עוצמתיות להשלמה אוטומטית.
  • כוונון לפי הוראות הוא כוונון עדין של מודל שאומן מראש, כדי לשפר את היכולת שלו לפעול לפי הוראות והנחיות ספציפיות. אלה המודלים ש'יודעים איך לנהל שיחה'.
  • וריאציות של מודלים: מודלים פתוחים בדרך כלל מפורסמים בכמה גדלים (למשל, ל-Gemma 3 יש גרסאות עם 1B,‏ 4B,‏ 12B ו-27B פרמטרים) ווריאציות, כמו גרסאות שעברו כוונון לפי הוראות (-it), גרסאות שעברו אימון מראש או גרסאות שעברו קוונטיזציה לצורך יעילות.
  • דרישות משאבים: מודלים גדולים של שפה הם גדולים ודורשים משאבי מחשוב משמעותיים כדי לארח אותם. אפשר להריץ אותם באופן מקומי, אבל פריסה שלהם בענן מספקת ערך משמעותי, במיוחד כשמבצעים אופטימיזציה לביצועים ולגמישות באמצעות כלים כמו Ollama.

למה כדאי להשתמש ב-GKE להצגת מודלים פתוחים?

בשיעור ה-Lab הזה תלמדו איך לעבור מהרצה פשוטה של מודל מקומי לפריסה מלאה של המודל בסביבת ייצור ב-Google Kubernetes Engine ‏ (GKE). כלים כמו Ollama מצוינים ליצירת אב טיפוס מהיר, אבל בסביבות ייצור יש דרישות מחמירות ש-GKE יכול לעמוד בהן באופן ייחודי.

כדי להפעיל אפליקציות AI בקנה מידה גדול, אתם צריכים יותר ממודל פעיל. אתם צריכים תשתית עמידה, ניתנת להרחבה ויעילה להצגת מודלים. פלטפורמת GKE מספקת את הבסיס הזה. מתי כדאי לבחור ב-GKE ולמה:

  • ניהול פשוט יותר באמצעות Autopilot: ‏GKE Autopilot מנהל את התשתית הבסיסית בשבילכם. אתם מתמקדים בהגדרת האפליקציה, ו-Autopilot מקצה משאבים לצמתים ומשנה את גודלם באופן אוטומטי.
  • ביצועים גבוהים ומדרגיות: התמודדות עם תעבורה תובענית ומשתנה באמצעות התאמה אוטומטית לעומס ב-GKE. כך אפשר לוודא שהאפליקציה יכולה לספק תפוקה גבוהה עם זמן אחזור נמוך, ולהגדיל או להקטין את הקיבולת לפי הצורך.
  • יעילות כלכלית בהיקף גדול: ניהול יעיל של משאבים. אפשר להגדיר את GKE כך שיקטין את עומסי העבודה עד לאפס כדי להימנע מתשלום על משאבים לא פעילים, ואפשר להשתמש במכונות Spot VM כדי לצמצם משמעותית את העלויות של עומסי עבודה של הסקת מסקנות ללא מצב.
  • ניידות ומערכת אקולוגית עשירה: הימנעות מנעילת ספק באמצעות פריסה ניידת שמבוססת על Kubernetes. בנוסף, GKE מספק גישה למערכת האקולוגית הענפה של Cloud Native ‏ (CNCF) לקבלת כלים לניטור, לרישום ביומן ולאבטחה ברמה הכי גבוהה.

בקיצור, כדאי לעבור ל-GKE כשהאפליקציה של ה-AI מוכנה לייצור ונדרשת פלטפורמה שמותאמת לשינוי גודל, לביצועים ולבגרות תפעולית.

מה תלמדו

בשיעור ה-Lab הזה תלמדו איך לבצע את המשימות הבאות:

  • מריצים מודל פתוח באופן מקומי באמצעות Ollama.
  • פריסת מודל פתוח ל-Google Kubernetes Engine‏ (GKE) Autopilot עם Ollama להצגה.
  • הסבר על המעבר ממסגרות פיתוח מקומיות לארכיטקטורת הגשה ברמת ייצור ב-GKE.

2. הגדרת הפרויקט

חשבון Google

אם אין לכם חשבון Google אישי, אתם צריכים ליצור חשבון Google.

משתמשים בחשבון לשימוש אישי במקום בחשבון לצורכי עבודה או בחשבון בית ספרי.

כניסה למסוף Google Cloud

נכנסים למסוף Google Cloud באמצעות חשבון Google אישי.

הפעלת חיוב

הגדרה של חשבון לחיוב לשימוש אישי

אם הגדרתם חיוב באמצעות קרדיטים של Google Cloud, אתם יכולים לדלג על השלב הזה.

כדי להגדיר חשבון לחיוב לשימוש אישי, עוברים לכאן כדי להפעיל את החיוב ב-Cloud Console.

הערות:

  • העלות של השלמת ה-Lab הזה במשאבי Cloud צריכה להיות פחות מ-1$.
  • כדי למחוק משאבים ולמנוע חיובים נוספים, אפשר לבצע את השלבים בסוף ה-Lab הזה.
  • משתמשים חדשים זכאים לתקופת ניסיון בחינם בשווי 300$.

יצירת פרויקט (אופציונלי)

אם אין לכם פרויקט שאתם רוצים להשתמש בו בשביל התווית הזו, אתם יכולים ליצור פרויקט חדש כאן.

3. פתיחת Cloud Shell Editor

  1. כדי לעבור ישירות אל Cloud Shell Editor, לוחצים על הקישור הזה.
  2. אם תתבקשו לאשר בשלב כלשהו היום, תצטרכו ללחוץ על אישור כדי להמשיך.לוחצים כדי לתת הרשאה ל-Cloud Shell
  3. אם הטרמינל לא מופיע בתחתית המסך, פותחים אותו:
    • לוחצים על הצגה.
    • לוחצים על Terminal (מסוף)פתיחת טרמינל חדש ב-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. הרצת Gemma עם Ollama

היעד הראשון שלכם הוא להפעיל את 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. משיכה (הורדה) של מודל Gemma 3 1B באמצעות Ollama:
    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.

שימוש ב-OpenAI SDK עם Ollama

עכשיו, כשהשירות Ollama פועל, אפשר ליצור איתו אינטראקציה באופן פרוגרמטי. תשתמשו ב-OpenAI Python SDK, שמתאים ל-API ש-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. פריסת Gemma באמצעות Ollama ב-GKE Autopilot

עבור עומסי עבודה בסביבת ייצור שדורשים פעולות פשוטות ומדרגיות, Google Kubernetes Engine‏ (GKE) היא הפלטפורמה המומלצת. במשימה הזו תפרסו את Gemma באמצעות Ollama באשכול GKE Autopilot.

‫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. התכונה 'טייס אוטומטי' תקצה באופן אוטומטי משאבי מחשוב (CPU וזיכרון) על סמך הדרישות שאתם מגדירים במניפסט הפריסה.

  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
    הסבר על ההגדרה של Autopilot:
    • ‫image: ollama/ollama:latest: כאן מצוין קובץ האימג' הרשמי של Ollama Docker.
    • ‫resources: אנחנו מבקשים במפורש 8 מעבדי vCPU ו-8Gi של זיכרון. מצב GKE Autopilot משתמש בערכים האלה כדי להקצות את המחשוב הבסיסי. מכיוון שאנחנו לא משתמשים ב-GPU, המודל יפעל ב-CPU. זיכרון בנפח 8Gi מספיק כדי להכיל את מודל Gemma 1B ואת ההקשר שלו.
    • ‫command/args: אנחנו משנים את פקודת ההפעלה כדי לוודא שהמודל נמשך כשה-Pod מתחיל. הסקריפט מפעיל את השרת ברקע, ממתין עד שהוא מוכן, שולף את מודל gemma3:1b ואז משאיר את השרת פעיל.
    • ‫OLLAMA_HOST: הגדרה של הערך הזה ל-0.0.0.0 מבטיחה ש-Ollama יאזין לכל ממשקי הרשת בקונטיינר, כך ששירות Kubernetes יוכל לגשת אליו.
  3. בטרמינל, מחילים את מניפסט הפריסה על האשכול:
    kubectl apply -f gemma-deployment.yaml
    יחלפו כמה דקות עד ש-Autopilot יקצה את המשאבים והפוד יתחיל לפעול. אפשר לעקוב אחרי השימוש באמצעות:
    ‫
    kubectl get pods --watch
    לפני שממשיכים, צריך להמתין עד שהסטטוס של ה-pod יהיה 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 חושף API שתואם ל-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. סיכום

מעולה! בשיעור ה-Lab הזה למדתם על כמה שיטות מרכזיות לפריסת מודלים פתוחים ב-Google Cloud. התחלתם עם הפשטות והמהירות של פיתוח מקומי באמצעות Ollama. לבסוף, פרסתם את Gemma בסביבה ניתנת להרחבה ברמת ייצור באמצעות Google Kubernetes Engine Autopilot ומסגרת Ollama.

עכשיו יש לכם את הידע הדרוש כדי לפרוס מודלים פתוחים ב-Google Kubernetes Engine לעומסי עבודה תובעניים וניתנים להרחבה, בלי לנהל את התשתית הבסיסית.

Recap

בשיעור ה-Lab הזה למדתם:

  • מהם מודלים פתוחים ולמה הם חשובים.
  • איך מריצים מודל פתוח באופן מקומי באמצעות Ollama.
  • איך פורסים מודל פתוח ב-Google Kubernetes Engine ‏ (GKE) Autopilot באמצעות Ollama להסקת מסקנות.

מידע נוסף