דף זה תורגם על ידי Cloud Translation API.

פירוט טכני של Gemini CLI

1. מבוא

היי כולם! קוראים לי נבחן! שמח שהגעת. הגעתי לכאן היום מאשכול GKE בus-central1. ברוכים הבאים ל-Codelab הזה.

ביליתי את כל חיי בחיפוש אחר נתונים ב-Google Cloud, וראיתי הכול. ראיתי אתכם, האדריכלים והמהנדסים, בונים דברים מדהימים. אבל ראיתי אותך גם נתקע בשיחים. אתה יודע על מה אני מדבר! התחושה של החלפת הקשר כשמבצעים ניפוי באגים של פוד ב-GKE. אתם עוברים בין kubectl logs, מסוף GCP כדי לבדוק את תקינות הצומת, סביבת הפיתוח המשולבת כדי לבדוק את קוד המקור שנפרס, וכרטיסיית דפדפן עם מסמכי Kubernetes הרשמיים בנושא מחזורי חיים של Pod. כל קפיצה היא הפרעה לריכוז!

וגם הכלים המורכבים! ‫gcloud, ‏ kubectl, ‏ terraform... לכל אחת מהן יש DSL משלה ואינספור דגלים. זה מוביל לחיפוש מתמיד של מסמכים. בסופו של דבר, אתם מחפשים את פקודת gcloud המושלמת עם השילוב הנכון של הדגלים --filter ו---format כדי לקבל את הנתונים שאתם צריכים. זה כמו לנסות למצוא אגוז ספציפי ביער של מיליוני אגוזים. ואני אפילו לא רוצה להתחיל לדבר על משימות חוזרות. ראיתי אותך כותב את אותו Dockerfile וcloudbuild.yaml כל כך הרבה פעמים בשביל שירות Python חדש, שהקוד כנראה חווה דז'ה וו.

אני כאן כדי להראות לכם דרך טובה יותר. שביל סודי ביער. בדיוק בשביל זה נוצר Gemini CLI.

מה זה Gemini CLI?

אז מהו קיצור הדרך הקסום הזה שאני כל כך מתרגש ממנו?

אפשר לחשוב על Gemini CLI כעל עוזר אישי בענן, שנמצא ממש בתוך הטרמינל. זו שיחה, שותפות! הוא מבין את ההקשר, כלומר הוא לא רק מקשיב, אלא גם מבין. הוא יכול לקרוא את הקבצים שלכם, ללמוד את המוסכמות של הפרויקט – למשל, אם אתם משתמשים בטאבים או ברווחים – ולהבין מה אתם מנסים לעשות. זה כמו שאני יכול להריח את הבלוטים שאתם מנסים לאסוף!

ארכיטקטורה ברמה גבוהה (בואו נציץ מתחת למכסה המנוע!)

אז איך זה עובד? זה שילוב של כמה דברים מגניבים שפועלים בהרמוניה:

מודל שפה עוצמתי: זה המוח! באופן ספציפי, זהו מודל גדול ומולטימודאלי שאומן על ידי Google. המונח מרובה מצבים מציין שהמודל לא רק מבין טקסט, אלא גם את המבנה והמשמעות של הקוד. כך הוא יכול להסיק מסקנות לגבי התוכנה שלכם, ולא רק לקרוא אותה.
ההקשר המקומי: זהו נתון חיוני. ממשק Gemini CLI פועל כתהליך במחשב המקומי שלכם, עם אותן הרשאות כמו בחשבון המשתמש שלכם. כלומר, הוא יכול לגשת למערכת הקבצים שלכם כדי לספק עזרה ספציפית לפרויקט. זה לא שירות ענן רחוק שמנחש לגבי הקוד שלכם, אלא שירות שנמצא ממש כאן איתכם.
מערכת אקולוגית של כלים: כך המודל מקיים אינטראקציה עם העולם. יש לה קבוצה מוגדרת היטב של פונקציות שהיא יכולה להפעיל – כמו read_file או run_shell_command. אפשר לחשוב על זה כמו על API מאובטח. המודל מחליט מה לעשות ובאיזה כלי להשתמש, ואז הוא יוצר בלוק tool_code כדי לבצע את הפעולה. כך הפעולות שלו צפויות ואמינות.
Shell Command Execution: This is the real magic! היא יכולה להריץ כל פקודה ב-subshell של bash -c <command>. הוא מצלם את stdout, stderr ואת exit code. זה ענק! המשמעות היא ש-Gemini CLI יכול להריץ פקודה, לבדוק אם היא נכשלה ואז לנסות לתקן אותה על סמך הודעת השגיאה.
רשת הביטחון: זה החלק האהוב עליי! לפני שהבלוק tool_code הזה מופעל, לקוח ה-CLI יציג לכם את הפקודה או הקוד exact ויבקש את האישור שלכם. זו בדיקה בצד הלקוח, כך שההחלטה הסופית היא שלכם לפני שמתבצעים שינויים במערכת. השליטה תמיד בידיים שלכם.

זה לא רק צ'אטבוט, זה גם עוזר אישי! עוזר פעיל בהרפתקה שלכם בתכנות.

המושג המרכזי: הצהרה לעומת ציווי

השינוי הכי גדול והכי מדהים הוא המעבר ממתן הוראות למחשב איך לעשות משהו, למתן הוראות מה רוצים שהוא יעשה.

ציווי (הדרך הישנה והמסובכת): צריך לתת כל שלב בנפרד. אתם צריכים להיות מומחים בשפה הספציפית של תחום הכלי. למשל, הפקודה המפלצתית הזו:
```
gcloud compute instances create my-vm --project=my-project --zone=us-central1-a --machine-type=e2-medium --image-family=debian-11 --image-project=debian-cloud --metadata-from-file startup-script=./startup.sh --tags=http-server,dev
```
אוי ואבוי! תראה את כל זה! צריך להכיר את התחביר של סוג המכונה, משפחת התמונות, המטא-נתונים והתגים. אם מפספסים חלק אחד, מקבלים שגיאה לא ברורה.
הצהרתי (קיצור הדרך של ספארקי!): פשוט אומרים מה רוצים באנגלית פשוטה.

Create a new e2-medium VM for my web server in us-central1, run the startup.sh script, and tag it for http traffic.

זהו! ‫Gemini מנתח את הבקשה, ממפה אותה לפרמטרים של הכלי gcloud, מבין מה התחביר הנכון לכל דגל ויוצר בשבילכם את הפקודה הגדולה והמפחידה הזו. ואז המערכת מציגה אותו לכם לאישור. המטרה היא לאפשר לכם לחשוב על התמונה הגדולה, ולא לזכור את כל התכונות הניסיוניות בשורת הפקודה.

הרחבת היכולות של Gemini: מבוא לתוספים ל-CLI

‫Gemini CLI הוא כלי רב עוצמה גם ללא תוספים, אבל כדי למצות את הפוטנציאל שלו צריך להשתמש בתוספים. תוספים הם חבילות של הנחיות, כלים ופקודות בהתאמה אישית שמשפרים את הפונקציונליות של CLI, ומאפשרים לכם להתאים אותו לצרכים ולתהליכי העבודה הספציפיים שלכם.

חיפוש והתקנה של תוספים

ל-Gemini CLI יש מערכת אקולוגית גדלה של תוספים שנבנו על ידי Google ועל ידי מפתחים חיצוניים. אפשר לעיין בספרייה הרשמית של התוספים בכתובת geminicli.com/extensions.

כדי להתקין תוסף, אפשר להשתמש בפקודה gemini extensions install עם כתובת ה-URL של מאגר ה-Git של התוסף. לדוגמה, כדי להתקין את התוסף הרשמי של Cloud SQL ל-PostgreSQL, מריצים את הפקודה:

gemini extensions install https://github.com/gemini-cli-extensions/cloud-sql-postgresql

אוקיי, מספיק דיבורים! בואו נתחיל ללכלך את הכפות וננסה את זה!

‫2. לפני שמתחילים

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

אם כבר יש לכם פרויקט ב-Google Cloud, אתם יכולים להשתמש ב-Gemini CLI ב-Cloud Shell, כי הוא מותקן מראש ב-Cloud Shell. אפשר גם לפעול לפי השלבים הבאים כדי להגדיר אותו במחשב המקומי.

שלב 1: הדרישות הבסיסיות (תנאים מוקדמים)

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

‫Google Cloud SDK (gcloud): ערכת הכלים העיקרית ל-Google Cloud. ‫Gemini CLI הוא חלק מהמשפחה הזו!

בודקים אם הוא מותקן: מריצים את הפקודה gcloud --version. אם מופיע מספר גרסה, אתם מוכנים להמשיך.
אם לא מותקן: פועלים לפי ההוראות הרשמיות בכתובת cloud.google.com/sdk/docs/install.

‫Git: נצטרך את הכלי הזה כדי לשכפל את מאגר ה-Lab המעשי.

בודקים אם הוא מותקן: מריצים את הפקודה git --version.
אם הוא לא מותקן: אפשר להוריד אותו מ-git-scm.com/downloads.

פרויקט GCP ואימות:

מוודאים שיש לכם פרויקט ב-Google Cloud עם חיוב מופעל. זה חשוב מאוד!
מתחברים לחשבון Google באמצעות הפקודה:

gcloud auth login

מגדירים את הפרויקט לסשן. מוצאים את מזהה הפרויקט במסוף GCP ומריצים את הפקודה:

gcloud config set project YOUR_PROJECT_ID

(מחליפים את YOUR_PROJECT_ID במזהה הפרויקט האמיתי!)

‫Node.js בגרסה 20 ואילך

שלב 2: מתחילים להשתמש בתכונה (התקנת Gemini CLI)

אחרי שהסברנו את הבסיס, הגיע הזמן להגיע לעיקר! נבצע התקנה של Gemini CLI.

הרצה מיידית באמצעות npx

# Using npx (no installation required)
npx https://github.com/google-gemini/gemini-cli

התקנה גלובלית באמצעות npm

npm install -g @google/gemini-cli

התקנה גלובלית באמצעות Homebrew‏ (macOS/Linux)

brew install gemini-cli

בדיקת הגרסה של Gemini

gemini --version

אמור להופיע מספר גרסה. ההודעה הזו מאשרת שההתקנה בוצעה בהצלחה.

שלב 3: הפעלה (הגדרה)

עכשיו, אחרי שמתקינים את Gemini CLI, צריך לתת לו את המפתחות לממלכה. קודם מריצים את הפקודה gemini במסוף כדי להפעיל אותו. אמור להופיע המסך הבא:

כדי לפשט את התהליך, אפשר לבצע אימות באמצעות חשבון Google. כך מקבלים גישה ל-Gemini 2.5 Pro עם חלון הקשר של מיליון אסימונים, ועד 60 בקשות בדקה ו-1,000 בקשות ביום, בלי צורך לנהל מפתח API.

אם אתם רוצים גישה למודלים ספציפיים של Gemini או לשדרג למגבלות גבוהות יותר כשצריך, אתם יכולים להשתמש במפתח Gemini API כשיטת האימות.

צוותים ב-Enterprise ועומסי עבודה בייצור שכבר הגדירו פרויקט Google וחשבון לחיוב יכולים להשתמש ב-Vertex AI כדי ליהנות מאבטחה ותאימות מתקדמות.

בהתאם לאפשרות שבחרתם, תופיע הנחיה עם השלבים הבאים להגדרת האימות. פרטים נוספים על האפשרויות האלה מופיעים במאמרי העזרה בנושא Gemini CLI.

אם אתם מתכוונים להשתמש בפלטפורמת Vertex AI של Google Cloud, קודם צריך לצאת מ-Gemini CLI על ידי הקשה על Ctrl+c פעמיים, ואז להגדיר את משתני הסביבה הנדרשים.

בדרך כלל צריך להגדיר את המשתנים הבאים, לא משנה באיזו שיטת אימות משתמשים: GOOGLE_CLOUD_PROJECT ו-GOOGLE_CLOUD_LOCATION.

כדי להגדיר את המשתנים האלה:

# Replace with your project ID and desired location (e.g., us-central1)
export GOOGLE_CLOUD_PROJECT="YOUR_PROJECT_ID"
export GOOGLE_CLOUD_LOCATION="YOUR_PROJECT_LOCATION"

עכשיו נכנסים ל-Google Cloud:

gcloud auth application-default login

אחרי שמתבצע אימות באמצעות השיטה הקודמת, מריצים שוב את Gemini CLI באמצעות הפקודה gemini במסוף. באפשרויות האימות, בוחרים באפשרות Vertex AI וזהו.

שלב 4: מבחן הניצוץ (אימות ההגדרה)

זה הרגע שבו נדע את האמת! בואו נבדוק אם הכול עובד. מריצים את הפקודות האלה כדי לוודא שכל האורות ירוקים.

מזינים את ההנחיה הבאה:

What is my current directory?

‫Gemini CLI אמור להגיב ולציין את ספריית העבודה הנוכחית. הבדיקה הזו בודקת את מודל השפה הבסיסי ואת השילוב של מעטפת הפקודות.

בדיקת החיבור ל-GCP:

list my gcs buckets

אם יש לכם דלי GCS, הוא אמור להופיע ברשימה. אם אין תמונות כאלה, תופיע הודעה על כך. כך תוכלו לוודא שהיא מקושרת לפרויקט שלכם ב-GCP בצורה נכונה.

שלב 5: מעניקים לו עוד כוחות על! (התקנת תוספים)

עכשיו נשפר את היכולות של Gemini CLI באמצעות התקנה של כמה תוספים שיעזרו לנו בהמשך ה-Lab.

Cloud Run

gemini extensions install https://github.com/GoogleCloudPlatform/cloud-run-mcp

אבטחה ב-Gemini CLI

gemini extensions install https://github.com/gemini-cli-extensions/security

gcloud

gemini extensions install https://github.com/gemini-cli-extensions/gcloud

Cloud SQL ל-PostgreSQL

gemini extensions install https://github.com/gemini-cli-extensions/cloud-sql-postgresql

אם כל הפקודות האלה פעלו, אתם מוכנים להשתתף בסדנה! הסביבה שלכם מוכנה, ואתם יכולים להתחיל להגביר את הפרודוקטיביות. נתראה בשיעור ה-Lab הראשון!

3. מושגי ליבה ואינטראקציה עם Workspace מקומי

אוקיי, מוכנים ללכלך את הכפות? עכשיו נסביר על הכלים בפועל בערכת הכלים החדשה של Gemini. אני רואה בהם את כוחות העל שלי לחקר ולבנייה בענן! בואו נתעמק קצת בפרטים הטכניים של אופן הפעולה שלהם.

יכולות הליבה

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

הסבר על הסביבה (חושים על-אנושיים!)

לפני שמתחילים לבנות קן חדש, צריך לבדוק את העץ, נכון? הכלים האלה עוזרים להבין את המצב.

‫list_directory: זה הכלי הבסיסי שלי ל'חיפוש'. זהו wrapper פשוט סביב רישום ספריות ברמת מערכת ההפעלה. אבל החלק המעניין הוא שהמודל יכול לנתח את הפלט המובנה הזה כדי לקבל החלטות, כמו בחירה לחקור ספריית משנה בשם src.
‫glob: זהו 'איתור הבלוטים' שלי! היא משתמשת בתבניות glob רגילות – כמו *,‏ **,‏ ? ו-[] – שאתם כבר מכירים משימוש ב-.gitignore. לכן, אפשר לשאול 'תמצא את כל הקבצים מסוג *.py בספרייה app' באמצעות התבנית app/**/*.py. זו דרך יעילה לאסוף קבוצה ספציפית של קבצים שהמודל ינתח.
‫search_file_content: זו ראיית הרנטגן שלי! החיפושים מתבססים על ביטויים רגולריים מלאים (regex), ולא רק על התאמה פשוטה של מחרוזות. זה כלי חזק מאוד. אפשר לבקש ממנו למצוא דפוסים מורכבים, כמו 'מצא את כל המסלולים של Flask שמשתמשים בשיטת POST', ואז הוא עשוי ליצור ביטוי רגולרי כמו app\.route\(.*methods=\['POST'\].*\). היא מחזירה את נתיב הקובץ, מספר השורה והשורה התואמת, וכך מספקת למודל את כל ההקשר שהוא צריך.
‫read_file: אחרי שמצאתם קובץ מעניין, כדאי לפתוח אותו. הקמפיין read_file מותאם לכך. אפשר לקרוא קובץ שלם, או, אם מדובר בקובץ גדול, אפשר להשתמש בפרמטרים offset ו-limit כדי לקרוא אותו במקטעים. כלומר, המודל יכול לסרוק ביעילות גם קובצי יומן גדולים מאוד בלי להגיע למצב פסק זמן.

מהבנה לפעולה (הגיע הזמן ליצור!)

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

‫**write_file**: רוצים ליצור קובץ חדש מאפס? ‫write_file היא פעולה אטומית שכותבת את התוכן המלא שאתם מספקים לנתיב שצוין. הוא מושלם ליצירת מודולים חדשים או ליצירת Dockerfile מאפס על סמך הצרכים של הפרויקט.
‫**replace**: הכלי הזה מיועד לשינויים כירורגיים! זה לא רק חיפוש והחלפה פשוטים. אתם מספקים old_string וnew_string. כדי שהפעולה הזו תתבצע בצורה בטוחה, קטע הקוד old_string צריך להיות קטע ייחודי מהקובץ, בדרך כלל עם כמה שורות של הקשר לפני ואחרי החלק שמשנים. כך אנחנו מוודאים שאנחנו משנים רק את החלק exact בקוד שרציתם לשנות.
‫**run_shell_command**: זהו שדרוג העוצמה האולטימטיבי! היא מריצה את הפקודה שצוינה בתת-מעטפת bash -c <command>. המודל מקבל בחזרה את stdout, את stderr ואת exit code. זה חשוב מאוד ליצירת תהליכי עבודה. המודל יכול להריץ terraform plan, לקרוא את הפלט, ואם התוכנית מצליחה (קוד יציאה 0), הוא יכול לשאול אתכם אם להחיל אותה.

רשת הביטחון (ההבטחה שלי אליך!)

יכול להיות שאתם חוששים להריץ פקודות. הבנתי! לכן חשוב כל כך להשתמש ברשת הביטחון. כשהמודל יוצר בלוק tool_code שמכיל קריאה ל-run_shell_command או ל-write_file, לקוח Gemini CLI מיירט אותו. הוא מציג לכם את הפקודה המדויקת או את התוכן המלא של הקובץ שייכתב, ומציג לכם הנחיה [y/n]. שום דבר לא קורה בלי אישור מפורש מכם. השליטה תמיד בידיים שלכם.

4. הסבר על פרויקט

המטרה: להשתמש ב-Gemini CLI כדי להבין בסיס קוד לא מוכר בלי לצאת מהטרמינל.

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

משימה 0: הגדרה – שיבוט הפרויקט

קודם כל, צריך לקבל את הקוד. הוא מוסתר במאגר ציבורי ב-GitHub, ב'עץ' שנקרא quickpoll. נבקש מ-Gemini CLI לשכפל אותו בשבילנו. לפני כן, ניצור ספריית עבודה ונפעיל את Gemini CLI מתוך ספריית העבודה:

mkdir workdir
cd workdir
gemini

עכשיו מקלידים את ההנחיה הבאה:

clone the github repository from the URL: https://github.com/gauravkakad-google/quickpoll.git

‫Gemini יבין שהמילה 'שיבוט' מתייחסת לשימוש בפקודה git clone. הוא ייצור קריאה לכלי run_shell_command עם משהו כמו git clone https://github.com/gauravkakad-google/quickpoll.git. אחרי שתאשרו את ההורדה, המאגר יורד למחשב.

עכשיו נצא מ-Gemini CLI על ידי הקשה על ctrl+c פעמיים, נעבור למאגר הדוגמאות ונפעיל שוב את Gemini CLI:

cd quickpoll
gemini

נהדר! עכשיו, אחרי שנכנסנו לעץ הפרויקט, אפשר להתחיל לחקור!

משימה 1: הצגת רשימה של כל הקבצים בפרויקט

עכשיו, אחרי שנכנסנו, נשרטט את כל היער. אנחנו רוצים לראות כל קובץ בנפרד. אפשר לשאול את Gemini:

List all the files in the project.

‫Gemini כנראה ישתמש בכלי glob עם התבנית **/*. כך מוצגת רשימה רקורסיבית של כל הקבצים, ומתקבל מניפסט מלא של בסיס הקוד. זהו שלב ראשון מצוין להבנת המבנה של הפרויקט.

משימה 2: חיפוש כל הקבצים שמייבאים את google.cloud.sql.connector

אוקיי, זה מסקרן אותי. איפה הפרויקט הזה מתקשר עם Google Cloud Storage? בואו ננסה לפתור את התעלומה. אפשר לשאול:

Find all files that import the 'google.cloud.sql.connector' library.

‫Gemini ימצא את הקבצים המדויקים שמכילים את הצהרת הייבוא הזו באמצעות יכולות ה-search_file_content שלו. כך תוכלו להתמקד מיד בחלקים בקוד שמטפלים באינטראקציה עם Cloud SQL. בפרויקט הזה, הוא אמור למצוא את backend/main.py.

משימה 3: הצגת התוכן של קובץ ה-Dockerfile הראשי

אני רואה Dockerfile! זהו התרשים של מאגר התגים שלנו. בואו נציץ פנימה. פשוט אומרים:

Show me the contents of the main Dockerfile.

‫Gemini ישתמש ב-read_file כדי להציג את Dockerfile. אפשר לנתח את תמונת הבסיס (FROM), את התלות שמותקנת (RUN pip install...) ואת הפקודה הסופית (CMD). כך אפשר לקבל מידע על סביבת זמן הריצה של האפליקציה.

משימה 4: מה המטרה של הקובץ `main.py`?

בסדר, הגיע הזמן להסתכל על ליבת הקוד. נבקש מ-Gemini להדריך אותנו. אומרים:

What's the purpose of the `main.py` file?

כאן Gemini CLI באמת מצטיין. קודם תתבצע התקשרות אל read_file בתאריך backend/main.py. לאחר מכן, מודל השפה הרב-אופני ינתח את קוד Python. הוא יזהה שמדובר באפליקציית FastAPI שמספקת API ל-REST לאפליקציית סקר. לאחר מכן, יוסבר על נקודות הקצה של ה-API והפונקציונליות שלהן. כך אתם חוסכים את הזמן שנדרש לקריאה ולהבנה של כל המידע בעצמכם. אפשר גם לשאול שאלות המשך כדי לקבל הסבר מפורט על חלק מהפונקציות האלה. מגניב, נכון? קדימה, כדאי לנסות!

5. ממקומי לשידור חי! פריסה באמצעות Cloud Run ו-Cloud SQL

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

המטרה: פריסת אפליקציית הסקר המהיר ב-Cloud Run, עם קצה עורפי של Cloud SQL ל-PostgreSQL.

משימה 1: ענף חזק לנתונים שלנו (הגדרת Cloud SQL)

כל אפליקציה טובה צריכה מקום לאחסן בו את הבלוטים היקרים שלה… התכוונתי לנתונים! נשתמש ב-Cloud SQL ל-PostgreSQL. זה כמו גן קסום שמטפל בעצמו במסד הנתונים שלנו, כדי שנוכל להתמקד בדברים המעניינים.

נבקש מ-Gemini CLI לשתול את הזרע במסד הנתונים שלנו.

Please create a new Cloud SQL for PostgreSQL instance for me in project <myproject>. Call it quickpoll-db and put it in us-central1. Lets use the Development preset for now, and make the root password a-very-secure-password!.

‫Gemini CLI יתחיל לפעול באמצעות התוסף Cloud SQL. יוצג לכם קריאה לכלי create_instance. אפשר לאשר את הבקשה.

אחרי שהמופע נוצר, אמור להופיע פלט שדומה לזה:

אפשר ליצור קובץ ‎ .env עם משתנה הסביבה שלמעלה ולהפעיל אותו לפני שמפעילים מחדש את Gemini CLI, כדי שתהיה לו גישה למשתנים האלה.

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

In the quickpoll-db instance, create a new database named quickpolldb.

‫Gemini CLI ישתמש בכלי create_database בתוסף Cloud SQL ל-PostgreSQL כדי ליצור את מסד הנתונים בשבילכם.

עכשיו נוסיף משתמש שיטפל בזה:

In the quickpoll-db instance, create a built in user named quickpoll-user with the password another-secure-password!.

הפעם, Gemini CLI ישתמש בכלי create_user.

משימה 2: הנתיב הסודי (חיבור הקצה העורפי)

הקצה העורפי שלנו צריך לדעת את הנתיב הסודי למסד הנתונים החדש שלנו. בואו נציץ לקובץ backend/main.py כדי לראות איך הוא מוצא את דרכו.

show me how would the backend/main.py connect to the database

הנה היא! ראית את זה? הוא משתמש ב-Cloud SQL Python Connector ומחפש משתני סביבה כמו CLOUD_SQL_POSTGRES_INSTANCE,‏ CLOUD_SQL_POSTGRES_USER,‏ CLOUD_SQL_POSTGRES_PASSWORD ו-CLOUD_SQL_POSTGRES_DATABASE. נצטרך לתת את הפרטים האלה לשירות Cloud Run שלנו.

קודם כל, אנחנו צריכים את CLOUD_SQL_POSTGRES_INSTANCE. זה כמו לחיצת יד סודית.

What are the details for the Cloud SQL instance quickpoll-db in us-central1?

יוצגו פרטים רבים. מחפשים את שם החיבור ומעתיקים את הערך הזה. היא תיראה בערך כך: your-project-id:us-central1:quickpoll-db.

לפני שנפרוס את האפליקציה ב-Cloud Run, ניצור מופע של מסד הנתונים עם הטבלאות הנדרשות. מכיוון שיצרנו מסד נתונים נפרד ומשתמש, נצא מ-Gemini CLI ונעדכן את הקובץ ‎ .env שיצרנו קודם עם הערכים החדשים:

export CLOUD_SQL_POSTGRES_USER=quickpoll-user
export CLOUD_SQL_POSTGRES_PASSWORD=password-you-provided
export CLOUD_SQL_POSTGRES_DATABASE=quickpolldb

עכשיו מפעילים מחדש את Gemini CLI ומזינים את הפקודה הבאה:

execute backend/database.sql file on quickpolldb database as quickpolluser in quickpoll-db instance

הוא הבין אוטומטית שהכלי execute_sql לא תומך בהרצת כמה פקודות SQL בקריאה אחת. לכן, הוא המשיך והריץ כל פקודת SQL בנפרד.

משימה 3: קצה עורפי, יוצאים לדרך! (פריסה ב-Cloud Run)

הגיע הזמן שהקצה העורפי שלנו יעזוב את הקן! אנחנו נגיד ל-Gemini לפרוס את תיקיית ה-backend ב-Cloud Run וניתן לו את נתיב הסוד למסד הנתונים.

Deploy the backend folder to a new Cloud Run service called quickpoll-be in us-central1. Here are the secrets (environment variables):
CLOUD_SQL_POSTGRES_INSTANCE=your-project-id:us-central1:quickpoll-db
CLOUD_SQL_POSTGRES_USER=quickpoll-user
CLOUD_SQL_POSTGRES_PASSWORD=password-you-provided
CLOUD_SQL_POSTGRES_DATABASE=quickpolldb

‫Gemini יארוז את הקוד, ייצור קובץ אימג' בקונטיינר ויפרוס אותו ב-Cloud Run. אחרי שהתהליך יסתיים (יכול להיות שיחלפו כמה דקות), תקבלו כתובת URL לשירות העורפי החדש. חשוב לשמור את כתובת ה-URL הזו בהישג יד.

משימה 4: הגימור הסופי (הגדרה ופריסה של חזית האתר)

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

Deploy the frontend folder to a new Cloud Run service called quickpoll-fe in us-central1. Here are the secrets (environment variables):
BACKEND_URL=backend-url

משימה 5: ההשקה הגדולה!

זהו זה! רגע האמת! מעתיקים את כתובת ה-URL של שירות quickpoll-fe ופותחים אותה בדפדפן האינטרנט.

אפליקציית QuickPoll אמורה להופיע, מוכנה לפעולה! אפשר ליצור סקר, להצביע ולראות את התוצאות מתעדכנות בזמן אמת.

כל הכבוד! העברתם פרויקט מהמחשב המקומי שלכם והפכתם אותו לפעיל ב-Google Cloud. והכול נעשה בנוחות מהטרמינל, בעזרת Gemini CLI, העוזר הנאמן שלכם.

זה מה שאני קורא פרודוקטיביות!

6. למפתחים – האצת מחזור חיי הפיתוח

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

מהרעיון לקוד

כדאי לחשוב על מחזור הפיתוח הטיפוסי. זה לא רק לכתוב קוד, נכון? הוא כולל פיגומים, הוספת טיפול בשגיאות, ארגון מחדש וכתיבת בדיקות. ‫Gemini יכול לעזור לכם בכל התהליך!

תכנים סטנדרטיים ומשימות חוזרות: לא צריך יותר להעתיק ולהדביק!

אוקיי, יש לך את הפונקציונליות הבסיסית של האפליקציה. עכשיו צריך להוסיף רישום ביומן ולטפל בשגיאות פוטנציאליות, נכון? בדרך כלל מדובר בהרבה בלוקים חוזרים של try...except. לא יותר! נתחיל בבקשה מ-Gemini CLI לנתח את הקוד ולהציע המלצות לשיטות מומלצות לרישום שגיאות ולטיפול בחריגים:

What are the best practices for error handling and logging that should also be included in this application?

ממשק Gemini CLI ינתח את הקובץ הקיים ויספק כמה המלצות לשיטות מומלצות. אפשר לחשוב על זה כעוזר מומחה שיכול לחסוך לכם זמן במחקר עצמאי.

עכשיו נבקש ממנו ליישם את ההמלצות האלה בשבילכם:

please go ahead and implement these in the existing app

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

שינוי מבנה הקוד: בודק הקוד האישי שלכם

כולנו רוצים לכתוב קוד נקי ויעיל. אבל לפעמים אנחנו ממהרים. ‫Gemini יכול לשמש כבודק קוד אישי. אפשר לשאול שאלות כמו:

please perform a comprehensive code review for best practices and security

‫Gemini מבין שיטות מומלצות שספציפיות לשפה. שוב, הפלט בפועל במקרה שלכם עשוי להיות שונה מהצילומים שלמעלה, אבל אם תקראו את הפלט תוכלו להבין את רמת הפירוט של ניתוח הקוד שבוצע באמצעות Gemini CLI. כך תוכלו ללמוד ולשפר את הקוד שלכם בו-זמנית.

יצירת מבחן: החלק הכי טוב!

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

Add a test suite to this application

‫Gemini ינתח את הפונקציה, יזהה את נתוני הקלט והפלט שלה ויגלה מהן התלויות שלה. לאחר מכן, המערכת תיצור קובץ test_main.py מלא עם כמה תרחישי בדיקה, כולל 'תרחיש אופטימי' ואולי תנאי שגיאה. זהו שיפור משמעותי בפרודוקטיביות!

הרצת הבדיקות (משימת אתגר בשבילך)

עכשיו מתחיל הכיף האמיתי! אשאיר את החלק הזה כאתגר בשבילך, כדי שתחקור אותו באופן עצמאי. אתם יכולים להנחות את Gemini CLI להריץ את מקרי הבדיקה שהוא יצר. אחרי זה, פשוט מתרווחים במושב וצופים בקסם מתרחש!

7. מעבר ל-Localhost: שילוב עם GitHub

עשינו עבודה מדהימה במחשב המקומי שלנו, בפינה הקטנה שלנו ביער. אבל היתרון האמיתי של הענן הוא שיתוף פעולה וחיבור! הגיע הזמן להמריא ולראות איך Gemini יכול ליצור אינטראקציה עם העולם הרחב, החל מהעץ הגדול ביותר ביער המפתחים: GitHub!

קונספט: העוזר המשולב שלכם ל-DevOps

עד עכשיו השתמשנו ב-Gemini כעוזר מקומי לכתיבת קוד. עכשיו אנחנו הולכים לשדרג אותו לעוזר DevOps משולב מלא. הכול מתאפשר בזכות השילוב של Model Context Protocol‏ (MCP). זה שם מפואר, אבל הוא פשוט אומר ש-Gemini יכול לתקשר בצורה מאובטחת עם שירותים אחרים בשמכם, והשירות הראשון שנתמקד בו הוא GitHub.

תחשוב על זה. כמה פעמים אתם צריכים לצאת מהטרמינל כדי לבדוק בקשת משיכה, ליצור issue או לעיין במאגר ב-GitHub? זה יותר מעבר הקשר! בעזרת ערכת הכלים של github, אפשר לעשות את כל זה ישירות כאן. הוא הופך את Gemini לממשק מקורי ל-GitHub.

במסמכי התיעוד הרשמיים של שרת ה-MCP של GitHub יש הנחיות מפורטות לגבי הכלים ואפשרויות ההגדרה שלו. אתם יכולים לבחור בין פעולה מקומית או מרחוק, כי Gemini CLI תומך באופן מלא בשני שרתי MCP מרחוק.

במדריך הזה מוסבר איך מגדירים את האפשרות Remote MCP Server (שרת MCP מרוחק) ל-GitHub. קודם כל, צריך Personal Access Token (PAT) מ-GitHub.

אחרי שמקבלים את ה-PAT, מוסיפים את אובייקט השרת של MCP לקובץ settings.json. הקובץ המלא שלי settings.json מוצג בהמשך, אבל אתם יכולים פשוט לוודא שאובייקט mcpServers שלכם זהה למה שמוצג כאן:

{
  "security": {
    "auth": {
      "selectedType": "vertex-ai"
    }
  },
 "mcpServers": {
    "github": {
      "httpUrl": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "GITHUB_PAT"
      },
      "timeout": 5000
    }
  }
}

אחרי שמעדכנים את הקובץ settings.json עם ההגדרה של שרת ה-MCP של GitHub, פשוט מפעילים מחדש את Gemini CLI או מריצים את הפקודה ‎ /mcp refresh. בצילום המסך שלמטה אפשר לראות את שרת ה-MCP של GitHub שמוכן עכשיו במערכת שלי, ומוצגות בו מגוון הכלים העוצמתיים ש-Gemini CLI יכול להשתמש בהם עכשיו באמצעות פרוטוקול הקשר של המודל.

דוגמאות לפקודות מקשים

‫Gemini מגיע עם סט חדש לגמרי של יכולות מתקדמות שמותאמות במיוחד ל-GitHub. הנה כמה מהאפשרויות האהובות עליי:

‫github.list_repositories: רוצים לראות את כל המאגרים בארגון בלי לפתוח דפדפן? זה הכלי שלכם! פשוט שואלים: 'תציג את כל המאגרים בארגון שלי'.
github.create_issue: מצאתם באג? לא צריך להחליף חלונות כדי ליצור בעיה. פשוט אומרים ל-Gemini, 'תצור בעיה במאגר sample-flask-app עם הכותרת "תיקון הבאג בהתחברות" והתיאור הבא...' ווואלה, הבעיה נוצרת.
‫github.get_pull_request: רוצה לבדוק את יחסי הציבור? אפשר לשאול: 'תציג לי את הפרטים של בקשת משיכה מספר 42 במאגר sample-flask-app'. ‫Gemini יאחזר את השם, התיאור, הסטטוס ופרטים על הבודקים.
github.get_file_contents: זה ממש מגניב. אתם יכולים לקרוא קובץ ממאגר מרוחק בלי לשכפל אותו קודם. הוא מצוין לבדיקה מהירה של קובץ הגדרות או של קובץ ה-README של פרויקט שאין לכם באופן מקומי.

8. GitHub Exploration

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

המטרה: שימוש ב-Gemini כדי לחקור ולהבין פרויקט שמתארח ב-GitHub.

תרחיש: אתם צריכים להכיר פרויקט ב-GitHub שעוד לא עבדתם עליו.

משימה 1: רשימת מאגרי מידע בארגון

קודם כל, נציג את כל הפרויקטים בארגון ב-GitHub. במעבדה הזו, אתם יכולים להשתמש בשם המשתמש שלכם ב-GitHub או בארגון שאתם שייכים אליו. נבקש מ-Gemini לפרט אותם.

List the repositories in the `[your-org-or-username]` GitHub organization.

(חשוב לזכור להחליף את [your-org-or-username] בפרטים שלכם!) ‫Gemini ישתמש בכלי github.list_repositories ויציג לכם רשימה של כל הפרויקטים. מדהים!

משימה 2: חיפוש מאגר ספציפי

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

משימה 3: רשימת בקשות פתוחות למשיכת קוד

אחרי שזיהינו את מאגר היעד, נבדוק מה קורה איתו. האם יש בקשות פתוחות למשיכת שינויים? בואו נשאל:

List the open pull requests for the `quickpoll` repository in the `[your-org-or-username]` organization.

‫Gemini ישתמש בכלי github.list_pull_requests ויסנן את התוצאות לפי המדינה open. לאחר מכן תופיע רשימה של כל בקשות ה-PR הפתוחות, עם מספר ה-PR, השם והיוצר. כאן אפשר לראות את הפיתוח הפעיל של הפרויקט. אפשר לנסות את זה עם מאגר שאתם תורמים לו באופן פעיל ולבדוק את התוצאות.

משימה 4: בדיקת בקשת מיזוג

נניח שיש ברשימה הזו יחסי ציבור מעניינים. אנחנו רוצים לדעת עוד על זה! אנחנו רוצים לראות את התיאור ואת הקבצים ששונו. בוחרים מספר PR מהרשימה (אם אין מספר כזה, אפשר לדלג על השלב הזה, אבל נניח שיש מספר כזה).

Show me the details and files changed in PR number 1 in the `quickpoll` repo.

זו דוגמה מצוינת למשימה מרובת שלבים ל-Gemini. קודם כל, הוא כנראה ישתמש ב-github.get_pull_request כדי לאחזר את הפרטים העיקריים – הכותרת, הגוף, המחבר וכו'. אחר כך, כדי לקבל את השינויים בקובץ, הוא ישתמש בכלי שני, github.get_pull_request_files. לאחר מכן, המידע הזה ישולב בסיכום ברור ונוח. ממש עכשיו בדקתם בקשת מיזוג בלי לצאת מהטרמינל! איזה יופי!

9. מ-PRD ועד ל-Initial Commit

למדתם איך לחקור, ליצור ולבדוק. עכשיו נשלב את כל מה שלמדנו בתרחיש מהחיים האמיתיים. זה הרגע שבו אנחנו הופכים תוכנית למוצר. נתחיל במסמך דרישות מוצר (PRD) ונגיע עד להתחייבות הראשונה שלנו. קדימה, נתחיל ליצור משהו מדהים!

המטרה: לדמות משימת פיתוח בעולם האמיתי מההתחלה ועד הסוף, תוך שילוב של הקשר מקומי ומרוחק.

תרחיש: הוקצתה לך תכונה חדשה! הדרישות מופיעות בקובץ PRD במאגר GitHub של הפרויקט.

משימה 1: הבנה – קוראים את מסמך דרישות המוצר (PRD)

זה השלב הכי חשוב! לפני שמתחילים לכתוב שורת קוד אחת, חשוב להבין את התוכנית. הדרישות של התכונה החדשה שלנו מופיעות בקובץ prd/NEW_FEATURE.md. בואו נפתח אותו ונראה מה יש בפנים.

explain the requirements mentioned in prd/NEW_FEATURE.md

‫Gemini CLI ישתמש בפונקציה read_file כדי להציג את התוכן של מסמך ה-PRD. קדימה, מתחילים! ההודעה תכלול הסבר על התכונה החדשה: כפתור רענון שמאפשר למשתמשים לעדכן ידנית את רשימת הסקרים הפעילים. תמיד כדאי להתייעץ קודם עם התוכנית!

משימה 2: קוד – תרגום הדרישות למציאות

זה הרגע הקסום! אנחנו ניקח את הדרישות ממסמך PRD ונבקש מ-Gemini לכתוב את הקוד בשבילנו. כדאי להיות ספציפיים ולהגיד לו בדיוק מה אנחנו רוצים.

Implement the changes as per the PRD

ממשק Gemini CLI יפעל, ואחרי רגע יוצגו נתונים שדומים לאלה שמופיעים בדוגמה הבאה. הקוד החדש והמבריק שלנו נמצא עכשיו במקום נוח!

משימה 3: בדיקת השינויים

יצרנו קובץ חדש עם קוד חדש. השלב האחרון בשיעור ה-Lab הזה הוא פריסת השינוי ב-Cloud Run ואימותו.

let's deploy the changes made to frontend to Cloud Run. The existing service on Cloud Run is quickpoll-fe in us-central1.

שימו לב שההנחיה הזו סיפקה פרטים נוספים, כמו שם שירות Cloud Run הקיים ואזור הפריסה שלו. כדאי להיות ספציפיים כדי לחסוך זמן, אבל Gemini CLI תמיד יבקש מכם להוסיף פרטים חסרים אם תשמיטו אותם.

אם שירות Cloud Run המעודכן ייתקל בשגיאה, פשוט תבקשו מ-Gemini CLI לנפות באגים ולתקן את הקוד. חשוב לזכור, זהו בן לוויה עם יכולות על!

10. מזל טוב

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