סביבת פיתוח

1. סקירה כללית

בשיעור ה-Lab הזה נדגים תכונות ויכולות שנועדו לייעל את תהליך העבודה של מהנדסי תוכנה שמפתחים אפליקציות Python בסביבה בקונטיינרים. בדרך כלל, פיתוח קונטיינרים דורש מהמשתמש להבין את הפרטים של הקונטיינרים ואת תהליך build של הקונטיינרים. בנוסף, מפתחים בדרך כלל צריכים להפסיק את תהליך העבודה שלהם, לצאת מסביבת הפיתוח המשולבת כדי לבדוק את האפליקציות שלהם ולנפות מהן באגים בסביבות מרוחקות. בעזרת הכלים והטכנולוגיות שמוזכרים במדריך הזה, מפתחים יכולים לעבוד ביעילות עם אפליקציות מבוססות-קונטיינרים בלי לצאת מסביבת הפיתוח המשולבת (IDE).

מה זה Cloud Workstations?

‫Cloud Workstations מספקת סביבות פיתוח מנוהלות ב-Google Cloud עם אבטחה מובנית וסביבות פיתוח שמוגדרות מראש אבל ניתנות להתאמה אישית. אפשר לגשת ל-Cloud Workstations דרך סביבת פיתוח משולבת (IDE) מבוססת-דפדפן, מכמה עורכי קוד מקומיים (כמו VSCode או סביבות פיתוח משולבות של JetBrains כמו IntelliJ IDEA Ultimate ו-PyCharm Professional), או דרך SSH.

ב-Cloud Workstations נעשה שימוש במשאבים הבאים:

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

‫Cloud Workstations מאפשר לאדמינים בתחום ה-IT והאבטחה להקצות, לשנות את קנה המידה, לנהל ולאבטח בקלות את סביבות הפיתוח שלהם, ולמפתחים לגשת לסביבות פיתוח עם הגדרות עקביות וכלים שניתנים להתאמה אישית.

‫Cloud Workstations עוזרת להעביר את האבטחה שמאלה על ידי שיפור מצב האבטחה של סביבות פיתוח האפליקציות. יש לו תכונות אבטחה כמו VPC Service Controls, תעבורת נתונים נכנסת או יוצאת פרטית, עדכון תמונה מאולץ וכללי מדיניות לגישה לניהול זהויות והרשאות גישה.

מה זה Cloud Code?

‫Cloud Code מספק תמיכה בסביבת פיתוח משולבת (IDE) למחזור הפיתוח המלא של אפליקציות Kubernetes ו-Cloud Run, החל מיצירה והתאמה אישית של אפליקציה חדשה מתבניות לדוגמה ועד להרצת האפליקציה המוגמרת. ‫Cloud Code תומך בכם לאורך כל הדרך עם דוגמאות מוכנות להרצה, קטעי קוד מוכנים להגדרה וחוויית ניפוי באגים מותאמת אישית – מה שהופך את הפיתוח באמצעות Kubernetes ו-Cloud Run להרבה יותר קל!

אלה כמה מהתכונות של Cloud Code:

• פיתוח והרצה של אפליקציות באופן רציף
• תמיכה בניפוי באגים באפליקציית Kubernetes שנמצאת בפיתוח
• סטרימינג של יומנים והצגה שלהם

מידע נוסף על תכונות אחרות של Cloud Code

מה תלמדו

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

• בדיקת Cloud Workstations
• הפעלת תחנת עבודה
• בדיקת Cloud Code
• ניפוי באגים ב-Kubernetes

2. הגדרה ודרישות

הגדרת סביבה בקצב עצמי

1. נכנסים ל-מסוף Google Cloud ויוצרים פרויקט חדש או משתמשים בפרויקט קיים. אם עדיין אין לכם חשבון Gmail או Google Workspace, אתם צריכים ליצור חשבון.

• שם הפרויקט הוא השם המוצג של הפרויקט הזה למשתתפים. זו מחרוזת תווים שלא נמצאת בשימוש ב-Google APIs. אפשר לעדכן את המיקום הזה בכל שלב.
• מזהה הפרויקט הוא ייחודי לכל הפרויקטים ב-Google Cloud, והוא קבוע (אי אפשר לשנות אותו אחרי שהוא מוגדר). מסוף Cloud יוצר באופן אוטומטי מחרוזת ייחודית, ובדרך כלל לא צריך לדעת מה היא. ברוב ה-Codelabs, תצטרכו להפנות למזהה הפרויקט (בדרך כלל הוא מסומן כ-PROJECT_ID). אם אתם לא אוהבים את המזהה שנוצר, אתם יכולים ליצור מזהה אקראי אחר. אפשר גם לנסות שם משתמש משלכם ולבדוק אם הוא זמין. אי אפשר לשנות את ההגדרה הזו אחרי השלב הזה, והיא תישאר כזו למשך הפרויקט.
• לידיעתכם, יש ערך שלישי, מספר פרויקט, שחלק מממשקי ה-API משתמשים בו. במאמרי העזרה מפורט מידע נוסף על שלושת הערכים האלה.

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

הערה: אם אתם משתמשים בחשבון Gmail, אתם יכולים להשאיר את מיקום ברירת המחדל כפי שהוא, ללא ארגון. אם אתם משתמשים בחשבון Google Workspace, אתם צריכים לבחור מיקום שמתאים לארגון שלכם.

2. בשלב הבא, תצטרכו להפעיל את החיוב במסוף Cloud כדי להשתמש במשאבי Cloud או בממשקי API של Cloud. העלות של התרגול הזה לא אמורה להיות גבוהה, ואולי אפילו לא תצטרכו לשלם בכלל. כדי להשבית את המשאבים ולא לחייב אתכם מעבר למדריך הזה, אתם יכולים למחוק את המשאבים שיצרתם או למחוק את כל הפרויקט. משתמשים חדשים ב-Google Cloud זכאים לתוכנית תקופת ניסיון בחינם בשווי 300$.

הגדרת הסביבה

ב-Cloud Shell, מגדירים את מזהה הפרויקט ואת מספר הפרויקט. שומרים אותם כמשתנים PROJECT_ID ו-PROJECT_ID.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \
    --format='value(projectNumber)')

בשיעור ה-Lab הזה תפרסו קוד ב-GKE. תשתמשו גם בתחנות עבודה בענן כסביבת פיתוח משולבת (IDE).

סקריפט ההגדרה שמופיע בהמשך מכין את התשתית הזו בשבילכם.

1. מורידים את סקריפט ההגדרה והופכים אותו לסקריפט שניתן להפעלה.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/python/setup_with_cw.sh
chmod +x setup_with_cw.sh

2. פותחים את הקובץ setup_with_cw.sh ועורכים את ערכי הסיסמאות שמוגדרים כרגע כ-CHANGEME
3. מריצים את סקריפט ההגדרה כדי להקים אשכול GKE שבו תשתמשו בשיעור ה-Lab הזה. ההגדרה תימשך כ-20 דקות.

./setup_with_cw.sh &

4. פותחים את Cloud Workstations ב-Cloud Console. לפני שממשיכים לשלבים הבאים, צריך להמתין עד שהסטטוס של האשכול יהיה READY.
5. אם הסשן של Cloud Shell התנתק, לוחצים על 'התחברות מחדש' ואז מריצים את הפקודה gcloud cli כדי להגדיר את מזהה הפרויקט. לפני שמריצים את הפקודה, מחליפים את מזהה הפרויקט לדוגמה שבהמשך במזהה הפרויקט שלכם ב-Qwiklabs.

gcloud config set project qwiklabs-gcp-project-id

6. מורידים ומריצים את הסקריפט שמופיע בהמשך במסוף כדי ליצור הגדרה של Cloud Workstations.

wget https://raw.githubusercontent.com/GoogleCloudPlatform/container-developer-workshop/main/labs/python/workstation_config_setup.sh
chmod +x workstation_config_setup.sh
./workstation_config_setup.sh

אשכול והגדרה של Cloud Workstations

פותחים את Cloud Workstations ב-Cloud Console. מוודאים שהאשכול נמצא בסטטוס READY.

בודקים את הסטטוס של ההגדרות הקיימות.

יוצרים תחנת עבודה חדשה.

משנים את השם ל-my-workstation ובוחרים הגדרה קיימת: codeoss-python.

הפעלת תחנת עבודה

1. מפעילים את תחנת העבודה. יחלפו כמה רגעים עד שתחנת העבודה תופעל.

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

3. לוחצים על 'האתר לא פועל?'.

4. לוחצים על 'אפשר להשתמש בקובצי Cookie'.

5. אחרי שהתחנה תופעל, יופיע Code OSS IDE.

לוחצים על 'סימון כהשלמה' בדף 'תחילת העבודה' ב-IDE של תחנת העבודה.

3. סקירה כללית על Cloud Code

סקירה של החלקים השונים שזמינים ב-Cloud Code.

• פיתוח Kubernetes סביבת פיתוח וניפוי באגים של Kubernetes שמשולבת באופן מלא בסביבת הפיתוח המשולבת (IDE). ליצור ולנהל אשכולות ישירות מתוך סביבת הפיתוח המשולבת.
• ניפוי באגים באפליקציות שפועלות. אפשר לנפות באגים בקוד בסביבות פיתוח משולבות (IDE) באמצעות Cloud Code ל-VS Code ו-Cloud Code ל-IntelliJ, על ידי שימוש בתכונות מובנות לניפוי באגים ב-IDE.
• מידע נוסף על פריסות הצגה של משאבים בסיסיים ומטא נתונים של אשכולות Kubernetes ושירותי Cloud Run. אתם יכולים לאחזר תיאור, להציג יומנים, לנהל סודות או לקבל מסוף ישירות לתוך פוד.
• מפשטים את הפיתוח המקומי ב-Kubernetes. מתחת לפני השטח, Cloud Code לסביבות פיתוח משולבות (IDE) משתמש בכלים פופולריים כמו Skaffold,‏ Jib ו-kubectl כדי לספק משוב רציף על הקוד בזמן אמת.

כניסה ל-Google Cloud

1. לוחצים על סמל Cloud Code ובוחרים באפשרות Sign in to Google Cloud (כניסה ל-Google Cloud):

2. לוחצים על 'המשך לכניסה'.

3. בודקים את הפלט ב-Terminal ופותחים את הקישור:

4. מתחברים באמצעות פרטי הכניסה שלכם ב-Qwiklabs.

5. בוחרים באפשרות 'אישור':

6. מעתיקים את קוד האימות וחוזרים לכרטיסייה של תחנת העבודה.

7. מדביקים את קוד האימות ומקישים על Enter.

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

4. יצירת אפליקציה חדשה ב-Python

בקטע הזה תיצרו אפליקציית Python חדשה.

1. פותחים חלון Terminal חדש.

2. יוצרים ספרייה חדשה ופותחים אותה כסביבת עבודה

mkdir music-service && cd music-service

code-oss-cloud-workstations -r --folder-uri="$PWD"

3. יוצרים קובץ בשם requirements.txt ומעתיקים אליו את התוכן הבא:

Flask
gunicorn
ptvsd==4.3.2

4. יוצרים קובץ בשם app.py ומדביקים בו את הקוד הבא:

import os
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/")
def hello_world():
    message="Hello, World!"
    return message

if __name__ == '__main__':
    server_port = os.environ.get('PORT', '8080')
    app.run(debug=False, port=server_port, host='0.0.0.0')

5. יוצרים קובץ בשם Dockerfile ומדביקים בו את הטקסט הבא

FROM python:3.8
ARG FLASK_DEBUG=0
ENV FLASK_DEBUG=$FLASK_DEBUG
ENV FLASK_APP=app.py
WORKDIR /app
COPY requirements.txt .
RUN pip install --trusted-host pypi.python.org -r requirements.txt
COPY . .
ENTRYPOINT ["python3", "-m", "flask", "run", "--port=8080", "--host=0.0.0.0"]

הערה: ההגדרה FLASK_DEBUG=1 מאפשרת לטעון מחדש באופן אוטומטי שינויים בקוד באפליקציית Python flask. קובץ ה-Dockerfile הזה מאפשר להעביר את הערך הזה כארגומנט של build.

יצירת קובצי מניפסט

בטרמינל, מריצים את הפקודה הבאה כדי ליצור skaffold.yaml ו-deployment.yaml כברירת מחדל

1. מאתחלים את Skaffold באמצעות הפקודה הבאה

skaffold init --generate-manifests

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

בוחרים אפשרות:

• 8080 ליציאה
• y כדי לשמור את ההגדרה

עדכון ההגדרות של Skaffold

• שינוי השם של אפליקציית ברירת המחדל
• פתיחה של skaffold.yaml
• בוחרים את שם התמונה שמוגדר כרגע כ-dockerfile-image
• לוחצים לחיצה ימנית ובוחרים באפשרות 'שינוי כל המופעים'.
• מקלידים את השם החדש בpython-app
• עורכים את הקטע build כדי
• הוספת docker.buildArgs לכרטיס FLASK_DEBUG=1
• סנכרון ההגדרות כדי לטעון שינויים בקבצים *.py מ-IDE למאגר פועל

אחרי העריכות, קטע ה-build בקובץ skaffold.yaml ייראה כך:

build:
 artifacts:
 - image: python-app
   docker:
     buildArgs:
       FLASK_DEBUG: "1"
     dockerfile: Dockerfile
   sync:
     infer:
     - '**/*.py'

שינוי קובץ ההגדרות של Kubernetes

1. שינוי השם שמוגדר כברירת המחדל

• פתיחת קובץ deployment.yaml
• בוחרים את שם התמונה שמוגדר כרגע כ-dockerfile-image
• לוחצים לחיצה ימנית ובוחרים באפשרות 'שינוי כל המופעים'.
• מקלידים את השם החדש בpython-app

5. הסבר על תהליך הפיתוח

אחרי שמוסיפים את הלוגיקה העסקית, אפשר לפרוס את האפליקציה ולבדוק אותה. בקטע הבא נראה איך משתמשים בפלאגין Cloud Code. בין השאר, הפלאגין הזה משתלב עם skaffold כדי לייעל את תהליך הפיתוח. כשפורסים ל-GKE בשלבים הבאים, Cloud Code ו-Skaffold יוצרים אוטומטית את קובץ האימג' של הקונטיינר, מעבירים אותו בדחיפה ל-Container Registry ואז פורסים את אפליקציית your ל-GKE. התהליך הזה מתבצע מאחורי הקלעים, והפרטים לא מוצגים בתהליך הפיתוח.

הוספת אשכול Kubernetes

1. הוספת אשכול

2. בוחרים באפשרות Google Kubernetes Engine:

3. בוחרים פרויקט.

4. בוחרים באפשרות python-cluster שנוצרה בהגדרה הראשונית.

5. האשכול מופיע עכשיו ברשימת אשכולי Kubernetes בקטע Cloud Code. מכאן אפשר לנווט באשכול ולעיין בו.

פריסה ב-Kubernetes

1. בחלונית שבתחתית Cloud Shell Editor, בוחרים באפשרות Cloud Code 

2. בחלונית שמופיעה בחלק העליון, בוחרים באפשרות Run on Kubernetes (הפעלה ב-Kubernetes).

אם מוצגת בקשה, בוחרים באפשרות Yes כדי להשתמש בהקשר הנוכחי של Kubernetes.

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

3. בפעם הראשונה שמריצים את הפקודה, מופיעה הנחיה בחלק העליון של המסך אם רוצים את ההקשר הנוכחי של Kubernetes. בוחרים באפשרות 'כן' כדי לאשר ולהשתמש בהקשר הנוכחי.
4. לאחר מכן תוצג בקשה לבחירת מאגר תמונות. מקישים על Enter כדי לאשר את ערך ברירת המחדל שמופיע
5. כדי לראות את ההתקדמות וההתראות, לוחצים על הכרטיסייה 'פלט' בחלונית התחתונה. בתפריט הנפתח, בוחרים באפשרות Kubernetes: Run/Debug (הפעלה/ניפוי באגים ב-Kubernetes).

6. בוחרים באפשרות Kubernetes: Run/Debug - Detailed (קובernetes: הפעלה/ניפוי באגים – מפורט) בתפריט הנפתח של הערוץ בצד שמאל כדי לראות פרטים נוספים ויומנים שמוזרמים בשידור חי מהקונטיינרים.

אחרי שהבנייה והבדיקות יסתיימו, כתובת ה-URL http://localhost:8080 תופיע ביומני הכרטיסייה Output בתצוגה Kubernetes: Run/Debug.

7. במסוף Cloud Code, מעבירים את העכבר מעל כתובת ה-URL הראשונה בפלט (http://localhost:8080), ואז בתיאור הכלים שמופיע בוחרים באפשרות 'פתיחת תצוגה מקדימה של האינטרנט'.
8. תיפתח כרטיסייה חדשה בדפדפן ותוצג בה ההודעה: Hello, World!

Hot Reload

1. פתיחת הקובץ app.py
2. שינוי הודעת הפתיחה לHello from Python

אפשר לראות מיד שבחלון Output, בתצוגה Kubernetes: Run/Debug, הכלי watcher מסנכרן את הקבצים המעודכנים עם הקונטיינר ב-Kubernetes

Update initiated
Build started for artifact python-app
Build completed for artifact python-app

Deploy started
Deploy completed

Status check started
Resource pod/python-app-6f646ffcbb-tn7qd status updated to In Progress
Resource deployment/python-app status updated to In Progress
Resource deployment/python-app status completed successfully
Status check succeeded
...

3. אם עוברים לתצוגה Kubernetes: Run/Debug - Detailed, אפשר לראות שהמערכת מזהה שינויים בקובץ, ואז בונה ומפעילה מחדש את האפליקציה

files modified: [app.py]
Syncing 1 files for gcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Copying files:map[app.py:[/app/app.py]]togcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Watching for changes...
[python-app] * Detected change in '/app/app.py', reloading
[python-app] * Restarting with stat
[python-app] * Debugger is active!
[python-app] * Debugger PIN: 744-729-662

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

ניפוי באגים

1. עוברים לתצוגת ניפוי הבאגים ומפסיקים את השרשור הנוכחי . אם תתבקשו, תוכלו לבחור לנקות אחרי כל הפעלה.
2. 
3. לוחצים על Cloud Code בתפריט התחתון ובוחרים באפשרות Debug on Kubernetes כדי להפעיל את האפליקציה במצב debug.

• בתצוגה Kubernetes Run/Debug - Detailed של החלון Output, אפשר לראות ש-skaffold יפרוס את האפליקציה הזו במצב ניפוי באגים.

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

מקישים על Enter כדי לאשר את ברירת המחדל

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

5. בסיום התהליך. תראו שהמנפה מחובר ושהכרטיסייה 'פלט' מציגה את ההודעה Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully., וכתובת ה-URL http://localhost:8080 מופיעה.

Port forwarding pod/python-app-8bd64cf8b-cskfl in namespace default, remote port 5678 -> http://127.0.0.1:5678

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

7. בתצוגה Kubernetes Run/Debug, אפשר לראות שהופעל קונטיינר שאפשר לנפות בו באגים.

**************URLs*****************
Forwarded URL from service python-app: http://localhost:8080
Debuggable container started pod/python-app-8bd64cf8b-cskfl:python-app (default)
Update succeeded
***********************************

שימוש בנקודות עצירה (breakpoint)

1. פתיחת הקובץ app.py
2. מחפשים את המשפט return message
3. מוסיפים נקודת עצירה לשורה הזו בלחיצה על השטח הריק שמימין למספר השורה. יוצג סימן אדום כדי לציין שהנקודה לעצירה מוגדרת
4. טוענים מחדש את הדפדפן ורואים שהדיבאגר עוצר את התהליך בנקודת העצירה ומאפשר לכם לבדוק את המשתנים ואת מצב האפליקציה שפועלת מרחוק ב-GKE.
5. לוחצים על הקטע VARIABLES (משתנים).
6. לוחצים על Locals (משתנים מקומיים) ומוצאים את המשתנה "message".
7. לוחצים לחיצה כפולה על שם המשתנה message ובחלון הקופץ משנים את הערך למשהו אחר, כמו "Greetings from Python"
8. לוחצים על הלחצן 'המשך' בחלונית הבקרה של ניפוי הבאגים
9. בודקים את התגובה בדפדפן, שבו מוצג עכשיו הערך המעודכן שהזנתם.
10. כדי לעצור את מצב 'ניפוי באגים', לוחצים על לחצן העצירה ומסירים את נקודת העצירה על ידי לחיצה עליה שוב.

6. הסרת המשאבים

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

כדי לנקות אחרי השלמת ה-Lab:

1. מחיקת הקבצים שבהם נעשה שימוש במעבדה

cd ~ && rm -rf ~/music-service

2. מחיקת הפרויקט כדי להסיר את כל התשתית והמשאבים שקשורים אליו

—

העדכון האחרון: 22 במרץ 2023