1. מבוא
הכירו את AllStrides, פלטפורמה לניהול אירועים מקצה לקצה לקהילות של חובבי כושר. למרות שיש בו הרבה תכונות, הסטטוס הנוכחי שלו הוא 'רק מקומי'. הוא מסתמך על מסד נתונים מקומי של SQLite ועל הפעלה ידנית של Node.js. כדי שהקהילה תגדל, AllStrides צריכה את הגודל, האמינות והאבטחה של Google Cloud.
ב-Codelab הזה לא תבצעו העברה מסורתית. במקום זאת, תפעל כארכיטקט מוצר, ותשתמש ב-Gemini CLI כשותף שלך. אם תציידו את Gemini בשלושה שרתים של פרוטוקול הקשר של מודלים (MCP) ב-Google Cloud, תאפשרו ל-AI 'לפנות' ולקיים אינטראקציה ישירה עם שירותי Google Cloud. תתחילו להשתמש ב-MCP של Developer Knowledge כדי לזהות את מסד הנתונים הכי טוב ב-Google Cloud לאפליקציית allstrides. לאחר מכן תשתמשו ב-MCP של Cloud SQL כדי להקצות מופע של מסד נתונים ולהעביר את נתוני הקהילה המקומיים לענן באמצעות הנחיה אחת. לבסוף, תשתמשו ב-MCP של Cloud Run כדי להכניס את האפליקציה לקונטיינר, וכך תהפכו את AllStrides לזמינה לשימוש בכל העולם.
דרישות מוקדמות
- הבנה בסיסית של מסוף Google Cloud
- מיומנויות בסיסיות בממשק שורת הפקודה וב-Cloud Shell
מה תלמדו
- איך פורסים את Gemini CLI כדי שיפעל עם MCP מרוחק
- איך משתמשים בשרת MCP של Development Knowledge
- איך משתמשים בשרת MCP מרוחק של Cloud SQL כדי להעביר נתונים לענן
- איך משתמשים בשרת ה-MCP המרוחק של Cloud Run כדי לפרוס אפליקציה בענן
- איך משתמשים ב-Gemini CLI ב-Google Cloud Shell
מה תצטרכו
- חשבון Google Cloud ופרויקט Google Cloud
- דפדפן אינטרנט כמו Chrome שתומך במסוף Google Cloud וב-Cloud Shell
2. הגדרה ודרישות
הגדרת פרויקט
- נכנסים ל-Google Cloud Console. אם עדיין אין לכם חשבון Gmail או Google Workspace, אתם צריכים ליצור חשבון.
משתמשים בחשבון לשימוש אישי במקום בחשבון לצורכי עבודה או בחשבון בית ספרי.
- יוצרים פרויקט חדש או משתמשים בפרויקט קיים. כדי ליצור פרויקט חדש במסוף Google Cloud, לוחצים בכותרת על הלחצן 'בחירת פרויקט' שפותח חלון קופץ.
בחלון Select a project (בחירת פרויקט), לוחצים על הלחצן New Project (פרויקט חדש) כדי לפתוח תיבת דו-שיח לפרויקט החדש.
בתיבת הדו-שיח, מזינים את שם הפרויקט המועדף ובוחרים את המיקום.
- שם הפרויקט הוא השם המוצג של המשתתפים בפרויקט הזה. השם של הפרויקט לא משמש את Google APIs, ואפשר לשנות אותו בכל שלב.
- מזהה הפרויקט הוא ייחודי לכל הפרויקטים ב-Google Cloud ואי אפשר לשנות אותו אחרי שהוא מוגדר. מסוף Google Cloud יוצר באופן אוטומטי מזהה ייחודי, אבל אפשר להתאים אותו אישית. אם לא אהבתם את המזהה שנוצר, אתם יכולים ליצור מזהה אקראי אחר או לספק מזהה משלכם כדי לבדוק אם הוא זמין. ברוב ה-codelabs, תצטרכו להפנות למזהה הפרויקט שלכם, שבדרך כלל מזוהה באמצעות placeholder בשם PROJECT_ID.
- לידיעתכם, יש ערך שלישי, מספר פרויקט, שחלק מממשקי ה-API משתמשים בו. במאמרי העזרה מפורט מידע נוסף על שלושת הערכים האלה.
הפעלת החיוב
הגדרת חשבון לחיוב לשימוש אישי
אם הגדרתם חיוב באמצעות קרדיטים ל-Google Cloud, אתם יכולים לדלג על השלב הזה.
- לוחצים על הקישור הזה ונכנסים לחשבון Google אישי.
- יוצג לכם משהו כזה:
- לוחצים על הלחצן כאן אפשר לגשת לזיכויים. תועברו לדף להגדרת פרופיל החיוב. אם מוצג לכם מסך הרשמה לתקופת ניסיון בחינם, לחצו על 'ביטול' והמשיכו לקשר את החיוב.
- לוחצים על 'אישור'. עכשיו אתם מחוברים לחשבון לחיוב ב-Google Cloud Platform לניסיון.
הגדרת חשבון לחיוב לשימוש אישי
אם הגדרתם חיוב באמצעות קרדיטים ל-Google Cloud, אתם יכולים לדלג על השלב הזה.
כדי להגדיר חשבון לחיוב לשימוש אישי, עוברים לכאן כדי להפעיל את החיוב ב-Cloud Console.
הערות:
- העלות של השלמת ה-Lab הזה במשאבי Cloud צריכה להיות פחות מ-3 דולר ארה"ב.
- כדי למנוע חיובים נוספים, אפשר למחוק את המשאבים לפי השלבים בסוף שיעור ה-Lab הזה.
- משתמשים חדשים זכאים לתקופת ניסיון בחינם בשווי 300$.
הפעלת Cloud Shell
אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל ב-codelab הזה תשתמשו ב-Google Cloud Shell, סביבת שורת פקודה שפועלת בענן.
ב-מסוף Google Cloud, לוחצים על סמל Cloud Shell בסרגל הכלים שבפינה הימנית העליונה:
אפשר גם ללחוץ על G ואז על S. אם אתם נמצאים במסוף Google Cloud, או אם אתם משתמשים בקישור הזה, רצף הפעולות הזה יפעיל את Cloud Shell.
יחלפו כמה רגעים עד שההקצאה והחיבור לסביבת העבודה יושלמו. בסיום התהליך, אמור להופיע משהו כזה:
המכונה הווירטואלית הזו כוללת את כל הכלים שדרושים למפתחים. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר מאוד את הביצועים והאימות ברשת. אפשר לבצע את כל העבודה ב-codelab הזה בדפדפן. לא צריך להתקין שום דבר.
3. לפני שמתחילים
הפעלת Basic API
כדי להשתמש בשירותים מנוהלים של מסדי נתונים כמו Cloud SQL ובשירותים אחרים כדי ליצור ולפרוס את האפליקציה שלכם ב-Cloud Run, אתם צריכים להפעיל את ממשקי ה-API המתאימים בפרויקט שלכם ב-Google Cloud.
בהתאם לגישה שלכם, אתם יכולים לדלג על השלב הזה ולאפשר ל-Gemini CLI להפעיל את כל ממשקי ה-API הנדרשים מאוחר יותר, אבל במקרה כזה יכול להיות שתיתקלו בעיכובים ובשלבים חוזרים במהלך ההרצה.
במסוף Cloud Shell, מוודאים שמזהה הפרויקט מוגדר:
gcloud config set project [YOUR-PROJECT-ID]
מגדירים את משתנה הסביבה PROJECT_ID:
PROJECT_ID=$(gcloud config get-value project)
מפעילים את כל השירותים הנדרשים:
gcloud services enable sqladmin.googleapis.com \
aiplatform.googleapis.com \
secretmanager.googleapis.com \
artifactregistry.googleapis.com \
cloudbuild.googleapis.com \
run.googleapis.com \
containerregistry.googleapis.com
הפלט אמור להיראות כך:
student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable sqladmin.googleapis.com \
aiplatform.googleapis.com \
secretmanager.googleapis.com \
artifactregistry.googleapis.com \
cloudbuild.googleapis.com \
run.googleapis.com \
containerregistry.googleapis.com
Operation "operations/acat.p2-812263612774-c2dbeef3-c4c1-4a7d-a4b2-b5380be65044" finished successfully.
מתן הרשאות לחשבון שירות
כדי ליצור ולאחסן תמונות של אפליקציות, צריך לתת הרשאות אדמין של אחסון לחשבון השירות שמוגדר כברירת מחדל ב-Compute Engine. כמו בשלב הקודם, יש לכם אפשרות להעביר את ההרשאה ל-Gemini CLI בהמשך התהליך.
PROJECT_ID=$(gcloud config get-value project)
gcloud projects add-iam-policy-binding $PROJECT_ID --member=serviceAccount:$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")-compute@developer.gserviceaccount.com --role=roles/storage.admin
הפעלת Remote MCP
צריך להפעיל באופן מפורש את שירותי ה-MCP המרוחקים לכל שירות בפרויקט. הם מושבתים כברירת מחדל ועוזרים לווסת את הגישה ל-API ברמת הפרויקט והשירות.
נתחיל עם שירות ה-MCP של Developer Knowledge. כדי להפעיל את Developer Knowledge API ואת שירות ה-MCP המרוחק, צריך להריץ את פקודות gcloud הבאות.
PROJECT_ID=$(gcloud config get-value project)
gcloud beta services mcp enable developerknowledge.googleapis.com --project=$PROJECT_ID
אחרי שמפעילים את ה-API ואת ה-MCP המרוחק של Developer Knowledge, אפשר להמשיך ולהפעיל את שירות ה-MCP המרוחק של Cloud SQL.
gcloud beta services mcp enable sqladmin.googleapis.com --project=$PROJECT_ID
בדומה לכל MCP מרחוק למסדי נתונים, הגישה וההרשאות ל-MCP מוענקות בשלבים, ומספקות גישה מפורטת ברמת הפרויקט ל-API עצמו. רק לחשבון משתמש (principal) עם התפקיד Service Usage Admin (roles/serviceusage.serviceUsageAdmin) יש אפשרות לעשות זאת.
ורק לגורמים עם התפקיד משתמש בכלי MCP (roles/mcp.toolUser) יש אפשרות לבצע קריאות ל-API של MCP מרחוק.
לדוגמה, אם אין לכם תפקיד Cloud SQL Admin (roles/cloudsql.admin), לא תוכלו ליצור, לשכפל או לעדכן אף מופע בפרויקט.
מידע נוסף על התפקידים וההרשאות הנדרשים זמין במסמכי התיעוד.
כפי שאפשר לראות, ההרשאה המדורגת והמפורטת מגנה עלינו מפני מתקפה לא מורשית גם כשנקודת הקצה המרוחקת של ה-MCP מופעלת, ולכן היא בטוחה מספיק לשימוש בסביבת הייצור שלנו.
ה-MCP המרוחק הבא שנפעיל הוא עבור שירות Cloud Run. הגישה להפעלת ה-MCP מרחוק ב-Cloud Run דומה לגישה להפעלת ה-MCP מרחוק ב-Cloud SQL.
מפעילים את שירות ה-MCP של Cloud Run באמצעות הפקודה הבאה.
gcloud beta services mcp enable run.googleapis.com --project=$PROJECT_ID
לבסוף, אפשר לאמת את כל שרתי ה-MCP המרוחקים שהופעלו בפרויקט באמצעות הפקודה הבאה.
gcloud beta services mcp list --project=$PROJECT_ID
הפלט אמור להיראות כך:
student@cloudshell:~ (test-project-001-402417)$ gcloud beta services mcp list --project=$PROJECT_ID NAME: services/developerknowledge.googleapis.com MCP_ENDPOINT: developerknowledge.googleapis.com NAME: services/run.googleapis.com MCP_ENDPOINT: run.googleapis.com/mcp NAME: services/sqladmin.googleapis.com MCP_ENDPOINT: sqladmin.googleapis.com/mcp
עכשיו, אחרי שהפעלנו את כל ה-API והשירותים, צריך להגדיר את Gemini CLI.
4. הגדרת Gemini CLI
בשיעור ה-Lab הזה נשתמש ב-Gemini CLI כסוכן הראשי לביצוע רוב הפעולות, והשלב הראשון הוא להגדיר אותו כך שיפעל עם שרתי MCP מרוחקים. מומלץ מאוד להשתמש בגרסה העדכנית של Gemini CLI ובגרסה העדכנית של Gemini, כמו Gemini-3-pro או Gemini-3-flash (שנמצאות כרגע בגרסת טרום-השקה).
אם כבר יש לכם את הגרסה העדכנית של Gemini CLI והגדרתם אותה לשימוש במודלים העדכניים של Gemini, אתם יכולים לדלג על 2 השלבים הבאים ולעבור ישירות לשלב 3.
1. קבלת מפתח Gemini API
כדי להשתמש במודלים העדכניים של Gemini ב-Gemini CLI, צריך להגדיר אימות באמצעות מפתח API. אפשר לקבל את מפתח ה-API ב-Google AI Studio
- בדפדפן, עוברים אל Google AI Studio -> Get API key.
- בצד שמאל של המסך, לוחצים על הלחצן
Create API key. - בחלון הקופץ בוחרים את הפרויקט או מייבאים אותו אם הוא לא מופיע שם.
- יוצרים את מפתח ה-API.
- אפשר להעתיק את המפתח באמצעות לחצן ההעתקה בצד שמאל.
המפתח מוכן ועכשיו אפשר להשתמש בו ב-Gemini CLI
2. הגדרת Gemini CLI
אפשר להגדיר את Gemini CLI באמצעות קובץ הגדרות או באופן אינטראקטיבי באמצעות הפקודה /settings. אנחנו רוצים שההגדרות שלנו יישמרו בקובץ ההגדרות.
קודם ניצור ספריה לפרויקט. נקרא לספרייה projectmcp ונעבור לספרייה הזו באמצעות הפקודות הבאות.
mkdir ~/projectmcp
cd ~/projectmcp
בספרייה ניצור ספרייה לקובצי ההגדרות של Gemini ונריץ את כל הפקודות שלנו. כברירת מחדל, Gemini CLI משתמש בקובץ תצורה של היקף משתמש ותוספים שמותקנים בספרייה ~/.gemini. אבל אנחנו ניצור הגדרה משלנו של היקף הפרויקט בתיקייה ~/projectmcp. נתחיל ביצירת תיקיית ההגדרות והקבצים.
mkdir ~/projectmcp/.gemini
touch ~/projectmcp/.gemini/settings.json
אחר כך פותחים את הקובץ ~/projectmcp/.gemini/settings.json באמצעות Cloud Shell Editor.
edit ~/projectmcp/.gemini/settings.json
בחלון העורך שנפתח, מוסיפים את ההגדרה הבאה.
{
"general": {
"preferredEditor": "vscode",
"previewFeatures": true,
"sessionRetention": {
"enabled": true
}
},
"ide": {
"enabled": true,
"hasSeenNudge": true
},
"security": {
"auth": {
"selectedType": "gemini-api-key"
}
},
"ui": {
"theme": "Default"
},
"tools": {
"shell": {
"enableInteractiveShell": false
}
}
}
אחרי עריכת הקובץ, אפשר להשתמש ב-ctrl+s כדי לשמור את השינויים ולחזור למסוף בלחיצה על הלחצן Open Terminal.
בקבצים שלמעלה מסוג settings.json, סוג האימות של Gemini CLI מוגדר כ-gemini-api-key, ואתם צריכים לספק את המפתח למודל. כדי לעשות את זה, יוצרים קובץ .env בספרייה שרוצים לעבוד איתה ב-Gemini CLI, ושומרים את מפתח ה-API לאימות ב-Gemini CLI כמשתנה סביבה שייקלט כשמפעילים את ה-IDE.
עריכת הקובץ באמצעות Cloud Shell Editor
edit ~/projectmcp/.env
מאחסנים את מפתח ה-API שנוצר בשלב 1.
GEMINI_API_KEY= <YOUR_API_KEY>
עכשיו אפשר לחזור למסוף ולהמשיך. בשלב הבא צריך לעדכן את Gemini CLI לגרסה העדכנית. יכול להיות שהגרסה ב-Google Cloud Shell או בסביבה שלכם תהיה מיושנת, ולא תפעל בצורה תקינה עם ההגדרות העדכניות ועם שירותי ה-MCP. לכן חשוב לעדכן את Gemini CLI לגרסה האחרונה ולהפעיל אותו. מריצים את הפקודה הבאה במסוף.
cd ~/projectmcp/
npm install -g @google/gemini-cli@latest
עכשיו אפשר לאמת את הגרסה. חשוב לזכור שאם אתם עובדים ב-Google Cloud Shell, יכול להיות שבכל פעם שתפעילו מחדש את ה-Shell הוא יחזור לגרסה הקודמת. השינויים שאתם מבצעים ב-Gemini CLI עצמו לא קבועים ב-Cloud Shell.
gemini --version
צריכה להופיע הגרסה העדכנית של Gemini CLI (גרסה 0.27 בזמן כתיבת המעבדה). כאן אפשר לבדוק מהי הגרסה העדכנית של Gemini CLI. עכשיו אפשר להפעיל אותו ולוודא שהוא משתמש במודל Gemini העדכני ביותר. מריצים את הפקודה הבאה בתיקיית הפרויקט כדי להפעיל את Gemini CLI.
gemini
כשמפעילים את Gemini CLI, אפשר לבדוק את הגרסה ואת המודל על ידי הרצת הפקודה /about בממשק. התוצאה אמורה להיות דומה לתמונה שלמטה.
אפשר לראות שהוא משתמש במודל Gemini-3 העדכני ביותר.
2. הגדרת שרתי MCP ב-Gemini CLI
עכשיו צריך להוסיף את כל שרתי ה-MCP המופעלים. יש שתי דרכים להפעיל אותם ב-Gemini CLI – באמצעות תוספים או ישירות בהגדרות. בשיעור ה-Lab הזה, תשתמשו בקובץ project scope setting.json ותוסיפו אליו את פרטי האימות של שרתי ה-MCP.
- בשרת Developer Knowledge MCP, צריך ליצור מפתח API כדי לקבל הרשאה בנקודת הקצה.
אלה השלבים:
- במסוף Google Cloud, בפרויקט שבו הפעלתם את ה-API, עוברים אל הדף Credentials.
- לוחצים על Create credentials (יצירת פרטי כניסה) ובתפריט בוחרים באפשרות API key (מפתח API). בתיבת הדו-שיח 'נוצר מפתח API' מוצגת המחרוזת של המפתח החדש שיצרתם.
- לוחצים על הקישור
Edit API keyבתיבת הדו-שיח. - בשדה
Name, נותנים שם למפתח. לדוגמהDK API Key. - בקטע API restrictions (הגבלות על ממשקי API), בוחרים באפשרות
Restrict key. - ברשימה Select APIs (בחירת ממשקי API), מפעילים את
Developer Knowledge APIולוחצים על OK (אישור). - לוחצים על 'שמירה'.
אם תצטרכו להשתמש במפתח, תוכלו לעבור לדף וללחוץ על 'הצגת המפתח' בצד שמאל.
עכשיו צריך לאחסן את המפתח הזה בהגדרה. הקטע MCP בקובץ settings.json ייראה כך (צריך להזין ערך למפתח ה-API של DK): דוגמה לאופן שבו נראה הקטע [MCP] בקובץ settings.json אם נוסף רק DK API. בהמשך שיעור ה-Lab הזה תראו גם איך קובץ settings.json אמור להיראות עם כל שרתי ה-MCP ביחד.
"mcpServers": {
"DeveloperKnowledge": {
"httpUrl": "https://developerknowledge.googleapis.com/mcp",
"headers": {
"X-Goog-Api-Key": "<Your DK API Key>"
}
}
},
- בשלב הבא, אפשר להוסיף הגדרות לשרת ה-MCP של Cloud SQL. ב-Cloud SQL MCP, תשתמשו בפרטי הכניסה שלכם ל-Google במקום ב-API. השיטה הזו מאובטחת יותר ומאפשרת לנו להגדיר תפקידים והיקף פעולות שמותר למשתמש לבצע. זו ההגדרה של שרת ה-MCP. מחליפים את הערך "<YOUR_GCP_PROJECT>" במזהה הפרויקט שלכם.
"Cloud SQL MCP Server": {
"httpUrl": "https://sqladmin.googleapis.com/mcp",
"authProviderType": "google_credentials",
"oauth": {
"scopes": [
"https://www.googleapis.com/auth/cloud-platform"
]
},
"timeout": 500000,
"trust": false,
"headers": {
"X-Goog-User-Project": "<YOUR_GCP_PROJECT>"
}
},
- בקטע הבא של JSON מופיעה ההגדרה של שרת Cloud Run MCP. הוא פועל לפי אותו דפוס כמו בדוגמה שלמעלה, ומשתמש בפרטי הכניסה של Google לאימות ולהרשאה. זוהי הגדרת הדוגמה.
"CloudRun": {
"httpUrl": "https://run.googleapis.com/mcp",
"authProviderType": "google_credentials",
"oauth": {
"scopes": [
"https://www.googleapis.com/auth/cloud-platform"
]
}
}
צריך להוסיף את כל אלה לקובץ ~/projectmcp/.gemini/settings.json.
פותחים את הקובץ ~/projectmcp/.gemini/settings.json באמצעות Cloud Shell Editor.
edit ~/projectmcp/.gemini/settings.json
ומחליפים את התוכן בהגדרה הבאה. עליך להזין את מפתח ה-API ואת מזהה הפרויקט בשדות X-Goog-Api-Key ו-X-Goog-User-Project בהתאם לסביבה שלך.
{
"general": {
"preferredEditor": "vscode",
"previewFeatures": true,
"sessionRetention": {
"enabled": true
}
},
"ide": {
"enabled": true,
"hasSeenNudge": true
},
"security": {
"auth": {
"selectedType": "gemini-api-key"
}
},
"mcpServers": {
"DeveloperKnowledge": {
"httpUrl": "https://developerknowledge.googleapis.com/mcp",
"headers": {
"X-Goog-Api-Key": "<Your DK API Key>"
}
},
"Cloud SQL MCP Server": {
"httpUrl": "https://sqladmin.googleapis.com/mcp",
"authProviderType": "google_credentials",
"oauth": {
"scopes": [
"https://www.googleapis.com/auth/cloud-platform"
]
},
"timeout": 500000,
"trust": false,
"headers": {
"X-Goog-User-Project": "<YOUR_GCP_PROJECT>"
}
},
"CloudRun": {
"httpUrl": "https://run.googleapis.com/mcp",
"authProviderType": "google_credentials",
"oauth": {
"scopes": [
"https://www.googleapis.com/auth/cloud-platform"
]
}
}
},
"ui": {
"theme": "Default"
},
"tools": {
"shell": {
"enableInteractiveShell": false
}
}
}
עכשיו אפשר להפעיל את Gemini CLI ולראות את כל שרתי ה-MCP שהופעלו.
cd ~/projectmcp/
gemini
כשמפעילים את Gemini CLI, אפשר להריץ את הפקודה /mcp כדי לראות את כל שרתי ה-MCP שפועלים.
5. הכנת הבקשה
בדוגמה הבאה ננסה להעביר את האפליקציה המקומית לדוגמה אל Google Cloud. קודם כול, מתקינים את האפליקציה באופן מקומי ובודקים אותה.
1. שכפול קוד המקור
צריך לשכפל את האפליקציה מהמאגר ב-GitHub. ב-Cloud Shell או בטרמינל המקומי, מריצים את הפקודה בתיקיית הפרויקט.
git clone https://github.com/google/mcp.git
2. הפעלת האפליקציה באופן מקומי
בואו נבדוק את האפליקציה ונטען כמה נתונים לדוגמה
באותו מעטפת, עוברים לתיקיית האפליקציה ומפעילים את האפליקציה באמצעות הפקודה
cd mcp/examples/allstrides
./start_allstrides.sh
3. בדיקת האפליקציה
אם אתם עובדים ב-Cloud Shell, לוחצים על הלחצן Web preview בחלק העליון של חלון Cloud Shell ובוחרים באפשרות Preview on port 8080.
תיפתח כרטיסייה חדשה בדפדפן עם ממשק האפליקציה, שבו אפשר למשל ללחוץ על הלחצן Events.
נכון לעכשיו, אין לך אירועים.
4. טעינת נתונים לדוגמה
אפשר להירשם לאפליקציה וליצור אירועים, הודעות צ'אט ומשתמשים משלכם, או להשתמש בנתונים לדוגמה שמצורפים לאפליקציה.
פותחים כרטיסייה נוספת ב-Cloud Shell באמצעות הסימן '+' בחלק העליון.
בכרטיסייה החדשה של Cloud Shell, עוברים לספריית האפליקציה ומבצעים ייבוא באמצעות כלי sqllite3:
cd ~/projectmcp/mcp/examples/allstrides
sqlite3 allstrides.db < seed_data.sql
אם תחזרו לדף האפליקציה ואז תלחצו שוב על הכפתור 'אירועים', אמורים להופיע כמה אירועים.
אפשר גם לבדוק את דף הצ'אט ולראות חלק מההודעות.
עכשיו אפשר לסגור את הכרטיסייה השנייה על ידי הקלדת exit
exit
מפסיקים את האפליקציה בכרטיסייה הראשונה באמצעות צירוף המקשים Ctrl+c.
6. בדיקת הידע של מפתחים ב-MCP
ה-MCP של Developer Knowledge מאפשר לנו להשתמש במסמכי Google ישירות מהכלים האגנוסטיים שלנו, ומספק לנו את האפשרות לאמת הוראות, ליצור הדרכות ולבצע משימות אחרות שאפשר לשפר באמצעות התיעוד העדכני של Google.
מפעילים את Gemini CLI ומציגים רשימה של כלי MCP שזמינים בשרת ה-MCP של Developer Knowledge.
/mcp
ב-MCP של Developer Knowledge (ידע למפתחים) אמורים להופיע שלושה כלים זמינים:
הפלט אמור להיראות כך:
🟢 DeveloperKnowledge - Ready (3 tools) Tools: - batch_get_documents - get_document - search_documents
המשימה שלנו היא להעביר את האפליקציה ל-Google Cloud, ולכן אנחנו צריכים לעבור ממסד נתונים מקומי של Sqlite לפתרון שניתן להרחבה ומתאים לענן. נבקש מ-Gemini לנתח את קוד האפליקציה שלנו ולתת לנו המלצות לגבי פתרון מסד הנתונים.
בהנחיה של Gemini CLI, מקלידים את הטקסט הבא:
Hello, I need to choose a database platform for my allstrides application in Google Cloud. Can you analyze documentation and prepare a tutorial to choose the correct database engine?
Gemini CLI יתחיל בניתוח הקוד ואז יבקש להריץ את
הפלט הצפוי
? search_documents (DeveloperKnowledge MCP Server) {"query":"choose google cloud database"} ← │
│ │
│ MCP Server: DeveloperKnowledge │
│ Tool: search_documents │
│ │
│ Allow execution of MCP tool "search_documents" from server "DeveloperKnowledge"? │
│ │
│ ● 1. Allow once │
│ 2. Allow tool for this session │
│ 3. Allow all server tools for this session │
│ 4. No, suggest changes (esc)
אנחנו יכולים לראות שהכלי משתמש ב-MCP כדי לעגן את התשובה באמצעות תיעוד של Google. אישור הביצוע של בקשת ה-MCP של Developer Knowledge. יכול להיות שהוא יבקש ממך עוד פעם או פעמיים לספק מידע נוסף לפני שהוא ייתן את התשובה. אל תאפש שינויים באפליקציה שלך בשלב הזה.
בסוף התהליך נוצר מדריך עם סיכום שבו Cloud SQL for Postgres הוגדר כבחירה הטובה ביותר למסד נתונים בקצה העורפי. יכול להיות שתקבלו תשובה שונה מעט בגלל האופי הלא דטרמיניסטי של מודלים של AI גנרטיבי.
הפלט אמור להיראות כך:
By switching to Cloud SQL for PostgreSQL, AllStrides gains a robust, scalable foundation suitable for production deployment on Google Cloud. The transition is straightforward due to the use of Sequelize ORM.
אנחנו יכולים גם לבקש להכין מדריך מפורט להעברת נתונים. מזינים הנחיה חדשה ל-Gemini CLI:
I agree with the recommendation to use Cloud SQL for PostgreSQL as the new database for my application. Can you prepare a detailed migration tutorial based on Google documentation on how to move data from my local database to Cloud SQL in the cloud?
גם כאן אנחנו מצפים ש-Gemini CLI ישתמש ב-MCP של Developer Knowledge כמקור האמת בזמן הכנת המדריך. רצף הפעולות שמבצע Gemini CLI יכול להיות שונה מעט בהתאם לדגם המדויק ולגורמים אחרים. לדוגמה, אפשר לבקש ממנו להכין קודם סקריפטים להעברה ורק אחר כך לעבוד על התיעוד הסופי של ההדרכה.
זו אחת הדוגמאות שבהן המערכת מבקשת הרשאה להפעיל את ה-MCP של Developer Knowledge:
? search_documents (DeveloperKnowledge MCP Server) {"query":"migrate local database to Cloud SQL for PostgreSQL"} ← │
│ │
│ MCP Server: DeveloperKnowledge │
│ Tool: search_documents │
│ │
│ Allow execution of MCP tool "search_documents" from server "DeveloperKnowledge"? │
│ │
│ ● 1. Allow once │
│ 2. Allow tool for this session │
│ 3. Allow all server tools for this session │
│ 4. No, suggest changes (esc) │
│ │
│ │
│ ⊷ search_documents (DeveloperKnowledge MCP Server) {"query":"import data into Cloud SQL PostgreSQL"}
יכול להיות שבמהלך ההרצה, Gemini CLI יבקש מכם להריץ פקודות מסוימות. לדוגמה, כדי להבין טוב יותר את סכימת הנתונים ולהכין הוראות נכונות להעברת הנתונים.
בסיום, הוא צריך להכין הוראות מפורטות להעברת נתונים.
אחר כך אפשר לבקש מ-Gemini CLI לכתוב את ההדרכה
Please write the tutorial down
ייווצר קובץ Markdown חדש עם מסמך ההדרכה.
הפלט אמור להיראות כך:
✦ I have created a detailed migration guide for you. You can find the tutorial in the new file: MIGRATION_GUIDE.md. This guide covers: 1. Exporting your local SQLite data to CSV format. 2. Creating the PostgreSQL schema with compatible data types. 3. Uploading data to Google Cloud Storage. 4. Importing data into Cloud SQL in the correct order to respect relationships. 5. Resetting ID sequences to ensure new data can be added without errors.
בשלב הבא נשתמש ב-Cloud SQL MCP כדי להכין את מסד הנתונים ולהעביר את הנתונים.
7. בדיקה של Cloud SQL Remote MCP
1. יצירת מופע ב-Cloud SQL
אפשר להתחיל בבדיקת הכלים שזמינים בשרת ה-MCP של Cloud SQL על ידי הקלדת /mcp ב-Gemini CLI
/mcp
בשלב הזה, הכלים הבאים זמינים לנו.
הפלט אמור להיראות כך:
🟢 Cloud SQL MCP Server - Ready (11 tools) Tools: - clone_instance - create_instance - create_user - execute_sql - get_instance - get_operation - import_data - list_instances - list_users - update_instance - update_user
כבר החלטנו להשתמש ב-Cloud SQL for Postgres כקצה העורפי של האפליקציה שלנו ב-Google Cloud. עכשיו אפשר לבקש מ-Gemini ליצור בשבילנו מכונה של Cloud SQL.
בהנחיה של Gemini CLI, מקלידים את הבקשה כמו בדוגמה הבאה:
Please create a Cloud SQL for Postgres instance with appropriate edition and version in the us-central1 region to be a backend for our application with a public IPs in the current project with 2 CPU and 8 GB memory.
כדי להימנע מביצוע שיחות נוספות לזיהוי הפרויקט הנוכחי, אפשר לציין במפורש את מזהה הפרויקט כשמזינים את ההנחיה. אם שם הפרויקט לא היה בשימוש בהקשר לפני כן, המודל יבקש את מזהה הפרויקט או יבקש להריץ פקודת gcloud כדי לזהות את הפרויקט.
לאחר מכן, המערכת תנתח את הכלים הקיימים ותבקש להפעיל את כלי ה-MCP של Cloud SQL. תוצג לכם בקשת האישור הבאה.
? create_instance (Cloud SQL MCP Server MCP Server) {"tier":"db-custom-2-8192","region":"us-central1","project":"gleb-test-short-001-486416","databaseVersion":"POSTGRES_17","edition":"ENTERPRISE","nam... ← │
│ │
│ MCP Server: Cloud SQL MCP Server │
│ Tool: create_instance │
│ │
│ Allow execution of MCP tool "create_instance" from server "Cloud SQL MCP Server"? │
│ │
│ ● 1. Allow once │
│ 2. Allow tool for this session │
│ 3. Allow all server tools for this session │
│ 4. No, suggest changes (esc)
אחרי שמתחילים את ההרצה, המערכת מבקשת לעקוב אחרי סטטוס הפעולה ואחרי בקשות שינה אפשריות בין הבדיקות. משהו כמו הדוגמה הבאה.
✦ I will wait for 30 seconds before checking the status of the instance creation. ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ ⊶ Shell sleep 30 [current working directory /home/gleb/demo] │ │ │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ⠋ Refining Instance Configuration (esc to cancel, 11s)
אחרי זה יופיע כלי get_operation ל-MCP של Cloud SQL Server.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ? get_operation (Cloud SQL MCP Server MCP Server) {"project":"gleb-test-short-001-486416","operation":"73c39ca7-65fe-46d1-bdb8-0dfa00000032"} ← │
│ │
│ MCP Server: Cloud SQL MCP Server │
│ Tool: get_operation │
│ │
│ Allow execution of MCP tool "get_operation" from server "Cloud SQL MCP Server"? │
│ │
│ ● 1. Allow once
אחרי בקשת get_instance האחרונה, אמור להתקבל מידע על המופע שנוצר. משהו כמו הדוגמה הבאה.
הפלט אמור להיראות כך:
✦ I will wait for 30 seconds before checking the status of the instance creation. ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ ⊶ Shell sleep 30 [current working directory /home/gleb/demo] │ │ │ ╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯ ⠋ Refining Instance Configuration (esc to cancel, 11s)
אחרי כן יתבצע שימוש בכלי get_operation עבור Cloud SQL Server MCP ושיחה עם כלי ה-MCP get_insance. יכול להיות שתיתקלו בבדיקות נוספות ובשיחה שבוצעה על ידי Gemini CLI כדי לוודא שהמשימה הושלמה בהצלחה.
The Cloud SQL for Postgres instance allstrides-db has been successfully created in the us-central1 region with 2 vCPUs and 8 GB of RAM. Instance Details: - Project ID: gleb-test-short-001-486416 - Instance Name: allstrides-db - Public IP Address: 35.226.187.246 - Database Version: POSTGRES_17 - Machine Type: db-custom-2-8192 (2 vCPU, 8 GB RAM) - Region: us-central1 - Connection Name: gleb-test-short-001-486416:us-central1:allstrides-db The instance is configured with public IP enabled, IAM authentication turned on, and Data API access allowed.
2. העברת נתונים
המכונה מוכנה ועכשיו אפשר להמשיך בהעברת כל הנתונים ממסד הנתונים הקיים של SQLite למסד נתונים חדש בענן.
בהנחיה של Gemini CLI, מקלידים את הבקשה הבאה
Now when we have our Cloud SQL instance ready it is time to move the data from our local database. Please migrate all the data to a new database in our Cloud SQL instance where the new user for application would be the database owner? Let's call the new database allstrides-db and the user allstrides. Please use our MCP tools whenever it is possible.
במהלך ההרצה, Gemini CLI ינתח את מודל הנתונים שלנו, ולשם כך הוא יבקש הרשאות להרצת פקודות מסוימות. תהליך העבודה לא דטרמיניסטי ב-100%, ויכול להיות שיהיו הבדלים בין השלבים.
דוגמה לאופן שבו השיחה יכולה להתחיל.
הפלט אמור להיראות כך:
✦ I will read the allstrides/README.md and allstrides/seed_data.sql files to understand the local database structure and data. ╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮ │ ✓ ReadFile allstrides/README.md │ │ │ │ │ │ ✓ ReadFile allstrides/seed_data.sql │ │ │ ╰─────────────────────────────────────────────────────────────────────────
לאחר מכן, אחרי כמה שלבים, המערכת תשתמש ב-Cloud SQL MCP כדי להכין את מסד הנתונים והמשתמש, ובסופו של דבר תעביר את הנתונים. אחת הפעולות הראשונות שהיא מבצעת במסד הנתונים היא להוסיף אתכם כמשתמש IAM ולהעניק לכם הרשאות ליצור מסד נתונים ומשתמש. צריכות להיות לכם הרשאות מספיקות ב-Google Cloud בתור IAM
הנה דוגמה לכמה שלבים בתהליך העבודה
הפלט אמור להיראות כך:
✓ execute_sql (Cloud SQL MCP Server MCP Server) {"project":"gleb-test-short-001-486416","instance":"allstrides-db","sqlStatement":"CREATE DATABASE \"allstrides-db\";","database":"postgres"} │
│ │
│ { │
│ "messages": [ │
│ { │
│ "message": "Execution complete. 1 result set(s) returned.", │
│ "severity": "INFO" │
│ } │
│ ], │
│ "metadata": { │
│ "sqlStatementExecutionTime": "0.075591388s" │
│ }, │
│ "results": [ │
│ {} │
│ ] │
│ } │
│
3. Deploy Application to Cloud Run
עכשיו, מסד הנתונים נוצר והנתונים של האפליקציה המקומית הועברו למסד הנתונים של CloudSQL. עכשיו אפשר לפרוס את האפליקציה ב-Cloud Run. במהלך הפריסה תשתמשו בשילוב של Google Cloud SDK כדי ליצור את קובץ האימג' ב-Google Cloud, ואז תפרסו אותו באמצעות Cloud Run MCP.
ב-Gemini CLI, מריצים את ההנחיה הבאה.
Now, when all the data is successfully migrated to our Cloud SQL instance allstrides-db we can migrate our allstrides application to Cloud Run and deploy using my Cloud SQL database. Please put the username and the password for my database user user to Secret Manager to not show openly in Cloud Run.
Let's build the image first and then use MCP to create the Cloud Run service.
במהלך ההרצה, המערכת תבדוק את ממשקי ה-API, תכין את הנתונים לניהול הסודות ותיצור את הסודות הנדרשים. בנוסף, הוא יעודכן כדי לעבוד עם מסד נתונים של PostgreSQL ויוסיף את מודולי ה-npm הנדרשים.
לאחר מכן, אחרי בניית האימג' והעברתו ל-Artifact Registry, המערכת משתמשת בשירות MCP כדי לפרוס את האפליקציה ב-Cloud Run.
הנה דוגמה לקריאה ל-MCP של Cloud Run
הפלט אמור להיראות כך:
✦ I will deploy the 'allstrides' service to Cloud Run using the deploy_service_from_image tool. I will configure the environment variables and map the
database credentials from Secret Manager. Note that the MCP tool's schema does not explicitly expose the Cloud SQL instance attachment parameter, which is
typically required for the Unix socket connection (/cloudsql/...) to work. I will proceed with the deployment as requested, but if the database connection
fails due to the missing instance attachment, we may need to use gcloud to update that specific configuration.
╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ Action Required 1 of 1 │
│ │
│ ? deploy_service_from_image (CloudRun MCP Server) {"service":{"invokerIamDisabled":true,"name":"projects/gleb-test-short-001-486416/locations/us-centra... │
│ │
│ MCP Server: CloudRun │
│ Tool: deploy_service_from_image │
│ Allow execution of MCP tool "deploy_service_from_image" from server "CloudRun"? │
│ │
│ ● 1. Allow once │
│ 2. Allow tool for this session │
│ 3. Allow all server tools for this session │
│ 4. No, suggest changes (esc) │
│ │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
הנתיב המדויק להשלמת כל הפעולות יכול להשתנות מהרצה להרצה. סוכני ה-AI בוחרים את הנתיב על סמך ההקשר, פלט הפקודה ועוד כמה משתנים. כאן טמונה העוצמה של תוכנה מבוססת-AI – היא יכולה להגיב, לשנות את הגישה ולנסות שוב לבצע שלבים כדי להשלים משימות ולהשיג תוצאות מוצלחות.
עכשיו אפליקציית allstrides פרוסה ופועלת ב-Cloud Run ומחוברת למסד הנתונים של Cloud SQL.
כך נראות התוצאות בסיום.
הפלט אמור להיראות כך:
✦ The application allstrides has been successfully migrated to Cloud Run and is connected to the Cloud SQL database allstrides-db.
Deployment Details:
* Service URL: https://allstrides-812263612774.us-central1.run.app
* Database: allstrides-db (PostgreSQL)
* Database User: allstrides (Password updated and stored in Secret Manager)
* Secrets: db-user and db-pass are mounted as environment variables.
* Region: us-central1
Steps Taken:
1. Database Configuration:
* Updated the allstrides database user password.
* Created db-user and db-pass secrets in Google Cloud Secret Manager.
* Updated database.ts to support PostgreSQL connections via Cloud SQL socket.
2. Build:
* Built the container image gcr.io/gleb-test-short-001-486416/allstrides using Cloud Build.
3. Deployment:
* Initiated deployment using the MCP deploy_service_from_image tool.
* Granted the Secret Manager Secret Accessor role to the Cloud Run service account.
* Attached the Cloud SQL instance connection using gcloud (as the MCP tool currently lacks this specific configuration parameter).
The application is now serving traffic and successfully connected to the database.
כשפותחים את כתובת ה-URL שסופקה בדפדפן, אמור להופיע דף האפליקציה.
וכל האירועים שלנו צריכים להיות גלויים שם
מעולה! הצלחתם להשתמש ב-Gemini CLI ובשירותי MCP מרחוק של Google Cloud כדי להעביר את האפליקציה המקומית שלכם לענן. כך מסתיימת הפריסה ואפשר למחוק את כל המשאבים.
8. ניקוי הסביבה
הדרך הקלה ביותר לנקות את הסביבה היא לבקש מ-Gemini CLI להסיר את כל הרכיבים שיצרתם. הוא צריך לשמור על כל הנכסים בהקשר. אבל אם מסיבה כלשהי התנתקתם ואין לכם היסטוריה שמורה, אתם יכולים לנסות להיות מדויקים יותר ולבקש לנקות את שירות Cloud Run, את התמונה ואת מופע Cloud SQL. כדי להסיר את השירות, צריך לאמת אותו באמצעות המשתמש שיש לו את ההרשאות הנדרשות ושישתמש בפקודת gcloud.
דוגמה להנחיה
Now, when we've tested the application can you please delete the created Cloud Run service, the image we've built and the Cloud SQL instance we've created in the project.
אחרי ההסרה, תוכלו להשתמש בשירותי ה-MCP המרוחקים כדי לוודא שהסרתם בהצלחה את שירות Cloud Run או את מופע Cloud SQL.
Can you please list all Cloud SQL instances in the project and Cloud Run services in the project.
בסוף התהליך אמורה להופיע הודעה כמו זו שבהמשך:
הפלט אמור להיראות כך:
✦ There are currently no Cloud SQL instances or Cloud Run services (in us-central1) in the project gleb-test-short-001-486416.
כאן מסתיימים השלבים של שיעור ה-Lab.
9. מזל טוב
כל הכבוד, סיימתם את ה-Codelab.
תוכנית הלימודים של Google Cloud
הנושאים שנדון בהם
- איך פורסים את Gemini CLI כדי שיפעל עם MCPs מרוחקים של Google Cloud
- איך משתמשים ב-Development KnowledgeMCP
- איך משתמשים ב-Cloud SQL MCP כדי להעביר נתונים לענן
- איך משתמשים ב-Cloud Run MCP כדי לפרוס אפליקציה בענן
- איך משתמשים ב-Gemini CLI ב-Google Cloud Shell
10. סקר
פלט: