פיתוח InnerLoop באמצעות תחנות עבודה בענן עם NodeJS

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

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

מה תלמדו

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

• יצירת אפליקציית Nodejs למתחילים
• הגדרת אפליקציית Nodejs לפיתוח קונטיינרים
• תכנות של שירות CRUD מסוג מנוחה פשוט
• פריסה ב-GKE
• ניפוי באגים במצב שגיאה
• שימוש בנקודת עצירה (breakpoint) / ביומנים
• שינויים בפריסה חמה בחזרה ב-GKE
• אופציונלי: שילוב של CloudSQL לשמירה על עקביות העורפי

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

הגדרת סביבה בקצב אישי

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

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

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

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

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

הפעלת Cloudshell Editor

שיעור ה-Lab הזה תוכנן ונבדק לשימוש עם Google Cloud Shell Editor. כדי לגשת לכלי העריכה:

1. ניגשים לפרויקט Google בכתובת https://console.cloud.google.com.
2. בפינה השמאלית העליונה, לוחצים על סמל העורך של Cloud Shell

3. חלונית חדשה תיפתח בחלק התחתון של החלון
4. לוחצים על הלחצן 'פתיחת העורך'.

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

הגדרת gcloud

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

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

הקצאת התשתית שבה נעשה שימוש בשיעור ה-Lab הזה

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

1. צריך להוריד את סקריפט ההגדרה ולהפוך אותו לניתן להפעלה.

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

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

./setup_with_cw.sh &

אשכול Cloud Workstations

1. פותחים את Cloud Workstations במסוף Cloud. ממתינים שהאשכול יהיה בסטטוס READY.

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

1. אם הסשן של Cloud Shell התנתק, צריך ללחוץ על Reconnect (התחברות מחדש). ואז מריצים את הפקודה cli של gcloud כדי להגדיר את מזהה הפרויקט. לפני הרצת הפקודה, צריך להחליף את מזהה הפרויקט לדוגמה שבהמשך במזהה הפרויקט ב-qwiklabs.

gcloud config set project qwiklabs-gcp-project-id

2. כדי ליצור תצורה של Cloud Workstations, צריך להוריד בטרמינל את הסקריפט הבא ולהריץ אותו.

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

3. מאמתים את התוצאות בקטע 'הגדרות אישיות'. המעבר לסטטוס READY יימשך 2 דקות.

4. פותחים את Cloud Workstations במסוף ויוצרים מכונה חדשה.

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

6. מאמתים את התוצאות בקטע 'תחנות עבודה'.

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

1. מפעילים את תחנת העבודה. תחנת העבודה תתחיל לפעול תוך כמה דקות.

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

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

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

5. ברגע שתושק תחנת העבודה, יופיע סביבת פיתוח משולבת (IDE) של Code OSS. לוחצים על 'סימון כ'בוצע''. בדף 'תחילת העבודה', סביבת הפיתוח המשולבת (IDE) של תחנת העבודה

3. יצירת אפליקציה חדשה ל-Nodejs למתחילים

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

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

2. יוצרים ספרייה חדשה ב-Cloud Shell בשם mynodejsapp

mkdir mynodejsapp

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

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

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

1. פותחים טרמינל חדש שוב. התקנת Node ו-NPM באמצעות NVM.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.2/install.sh | bash
        
        # This loads nvm bash_completion
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"  

nvm install stable

nvm alias default stable

4. יצירת אפליקציה חדשה לתחילת פעולה

1. הפעלת האפליקציה

יצירת קובץ package.json באמצעות הפקודה הבאה

npm init

    Choose the `entry point: (index.js) src/index.js` and leave default values for the rest of the parameters. This will create the `package.json` file with following contents

{
  "name": "mynodejsapp",
  "version": "1.0.0",
  "description": "",
  "main": "src/index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

2. הוספת נקודת כניסה

צריך לפתוח ולערוך את הקובץ package.json בסביבת הפיתוח המשולבת (IDE) כדי לכלול את פקודת ההתחלה בסקריפט "start": "node src/index.js",. אחרי השינוי, הסקריפטים אמורים להיראות כמו קטע הקוד הבא:

"scripts": {
    "start": "node src/index.js",
    "test": "echo \"Error: no test specified\" && exit 1"
  },

3. הוספת תלות אקספרס

הקוד שנוסיף גם משתמש ב-express אז אפשר להוסיף את התלות הזו לקובץ package.json הזה. אחרי כל השינויים, הקובץ package.json אמור להיראות כמו בדוגמה הבאה.

{
 "name": "mynodejsapp",
 "version": "1.0.0",
 "description": "",
 "main": "src/index.js",
 "scripts": {
   "start": "node src/index.js",
   "test": "echo \"Error: no test specified\" && exit 1"
 },
 "author": "",
 "license": "ISC",
 "dependencies": {
   "express": "^4.17.3"
 }
}

4. יוצרים את הקובץ index.js

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

יצירת קובץ src/index.js

עם הקוד הבא

const express = require('express');
const app = express();
const PORT = 8080;

app.get('/', (req, res) => {
    var message="Greetings from Node";
    res.send({ message: message });
  });

app.listen(PORT, () => {
  console.log(`Server running at: http://localhost:${PORT}/`);

});

חשוב לשים לב שהשדה PORT מוגדר לערך 8080

יצירת מניפסטים

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

מריצים את הפקודה הבאה בטרמינל

skaffold init --generate-manifests

כשמוצגת ההודעה:

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

שני קבצים נוספו ל-viz של Workspace, skaffold.yaml ו-deployment.yaml

עדכון שם האפליקציה

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

1. שינוי הערכים בהגדרות של Skaffold

• פתיחה של skaffold.yaml
• בחירת שם התמונה שמוגדר כרגע בתור package-json-image
• לוחצים לחיצה ימנית ובוחרים באפשרות 'שינוי כל המופעים'
• יש להקליד את השם החדש בתור mynodejsapp

2. שינוי רשומות בהגדרות של Kubernetes

• פתיחת קובץ אחד (deployment.yaml)
• בחירת שם התמונה שמוגדר כרגע בתור package-json-image
• לוחצים לחיצה ימנית ובוחרים באפשרות 'שינוי כל המופעים'
• יש להקליד את השם החדש בתור mynodejsapp

שימו לב שבקובץ skaffold.yaml, הקטע build משתמש ב-buildpacks כדי ליצור קונטיינרים של האפליקציה. הקוד הזה לא מכיל קובץ Docker והוא לא צריך ידע ב-Docker כדי ליצור קונטיינרים לאפליקציה הזו.

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

5. להדרכה על תהליך הפיתוח

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

Cloud Code משתלב עם skaffold כדי לייעל את תהליך הפיתוח. כשפורסים ב-GKE התהליך הזה מתרחש מאחורי הקלעים מבלי לכלול את הפרטים הנדרשים בתהליך הפיתוח. Cloud Code גם משפר את תהליך הפיתוח באמצעות יכולות מסורתיות של ניפוי באגים ו-hotsync לפיתוח מבוסס-קונטיינר.

כניסה ל-Google Cloud

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

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

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

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

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

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

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

הוספת אשכול Kubernetes

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

2. בחירת Google Kubernetes Engine:

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

4. בוחרים באפשרות mycluster" שנוצר בהגדרה הראשונית.

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

הגדרת מזהה הפרויקט הנוכחי באמצעות cli של gcloud

1. מעתיקים את מזהה הפרויקט לשיעור ה-Lab הזה מהדף qwiklabs.

2. בטרמינל, מריצים את הפקודה cli של gcloud כדי להגדיר את מזהה הפרויקט. לפני הרצת הפקודה, צריך להחליף את מזהה הפרויקט לדוגמה. צריך להחליף את מזהה הפרויקט לפני הרצת הפקודה הבאה.

gcloud config set project qwiklabs-gcp-project-id

פריסה ב-Kubernetes

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

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

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

4. בשלב הבא תוצג הודעה שמבקשת באיזה מרשם להשתמש. צריך להקיש על Enter כדי לאשר את ערך ברירת המחדל שצוין

5. בוחרים את הכרטיסייה Output בחלונית התחתונה ואת Kubernetes: Run/Debug בתפריט הנפתח כדי לראות את ההתקדמות וההתראות.

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

7. כדי לחזור לתצוגה הפשוטה, בוחרים באפשרות 'Kubernetes: הרצה/ניפוי באגים'. מהתפריט הנפתח
8. בסיום ה-build והבדיקות, תופיע בכרטיסייה 'פלט' ההודעה: Resource deployment/mynodejsapp status completed successfully, ובכרטיסיית ה'פלט' תופיע כתובת ה-URL: 'כתובת ה-URL שהועברה מאפליקציית ההדגמה של השירות: http://localhost:8080'
9. בטרמינל של Cloud Code, מעבירים את העכבר מעל כתובת ה-URL שמופיעה בפלט (http://localhost:8080) ואז בטיפ הכלי שמופיע, בוחרים באפשרות 'מעקב אחר קישור'.

התגובה תהיה:

{"message":"Greetings from Node"}

טעינה מחדש מתוך הזיכרון (hot Reload)

1. נווט אל src/index.js. עריכת הקוד של הודעת הפתיחה ל-'Hello from Node'

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

Update initiated
File sync started for 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
File sync succeeded for 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Update succeeded

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

files modified: [src/index.js]
Copying files:map[src/index.js:[/workspace/src/index.js]]togcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Syncing 1 files for gcr.io/myproject/mynodejsapp:latest@sha256:f554756b3b4d6c301c4b26ef96102227cfa2833270db56241248ae42baa1971a
Watching for changes...
[mynodejsapp]
[mynodejsapp]> mynodejsapp@1.0.0 start /workspace
[mynodejsapp]> node src/index.js
[mynodejsapp]
[mynodejsapp]Server running at: http://localhost:8080/

3. מרעננים את הדפדפן כדי לראות את התוצאות המעודכנות.

ניפוי באגים

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

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

Port forwarding pod/mynodejsapp-6bbcf847cd-vqr6v in namespace default, remote port 9229 -> http://127.0.0.1:9229
[mynodejsapp]Debugger attached.

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

4. בתצוגה Kubernetes Run/Debug, ניתן לראות שהופעל מאגר תגים שניתן לניפוי באגים

**************URLs*****************
Forwarded URL from service mynodejsapp-service: http://localhost:8080
Debuggable container started pod/mynodejsapp-deployment-6bc7598798-xl9kj:mynodejsapp (default)
Update succeeded
***********************************

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

1. פותחים את src/index.js.
2. יש למצוא את ההצהרה שבה כתוב var message="Hello from Node";
3. כדי להוסיף נקודת עצירה לשורה הזו, לוחצים על הרווח הריק שמימין למספר השורה. יוצג אינדיקטור אדום כדי לציין שנקודת העצירה הוגדרה
4. טוענים מחדש את הדפדפן ומציינים שהכלי לניפוי באגים עוצר את התהליך בנקודת העצירה (breakpoint) ומאפשר לכם לחקור את המשתנים והמצב של האפליקציה שרצה מרחוק ב-GKE
5. לוחצים למטה בקטע המשתנים עד שמוצאים את המשתנה "message".
6. כדי להפעיל את השורה, לוחצים על 'שלב מעל '
7. חשוב לבדוק את הערך הנוכחי של המשתנה "message" ל-"Hello from Node"
8. לוחצים לחיצה כפולה על שם המשתנה target (יעד) בחלון הקופץ, משנים את הערך למשהו אחר, כמו "Hi from Node"
9. לוחצים על הלחצן 'המשך' בלוח הבקרה של ניפוי הבאגים.
10. בודקים את התשובה בדפדפן, שמציגה עכשיו את הערך המעודכן שהזנתם.
11. איך מפסיקים את 'ניפוי הבאגים' במצב 'הפסקה', לוחצים שוב על לחצן העצירה ומסירים את נקודת העצירה בלחיצה חוזרת על נקודת העצירה.

6. פיתוח שירות CRUD מסוג מנוחה פשוט

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

הגדרת יחסי תלות

הקוד של האפליקציה משתמש במסד נתונים כדי לשמור את הנתונים של שירות השאר. כדי לוודא שיחסי התלות זמינים, צריך להוסיף את הפרטים הבאים בקובץ package.json

1. מוסיפים עוד שני יחסי תלות pg ו-sequelize לקובץ package.json כדי ליצור אפליקציית CRUD Postgres. מפרסמים את השינויים בקטע של יחסי התלות ייראה כך.

    "dependencies": {
    "express": "^4.17.3",
    "pg": "^8.8.0",
    "sequelize": "^6.25.7"
  }

כתיבת קוד של שירות ה-REST

1. מוסיפים את הקוד של אפליקציית CRUD לאפליקציה הזו

wget -O app.zip https://github.com/GoogleCloudPlatform/container-developer-workshop/raw/main/labs/nodejs/app.zip

unzip app.zip

לקוד הזה

• תיקיית models עם מודל הישות של item
• תיקיית בקרים עם הקוד שמבצע פעולות CRUD
• התיקייה ניתוב שמנתבת תבניות ספציפיות של כתובות URL לקריאות שונות
• תיקיית config עם פרטי קישוריות של מסד נתונים

2. לתשומת ליבכם: ההגדרה של מסד הנתונים בקובץ db.config.js מתייחסת למשתני הסביבה שצריך לספק כדי להתחבר למסד הנתונים. בנוסף, צריך לנתח את הבקשה הנכנסת לקידוד כתובת URL.
3. צריך להוסיף את קטע הקוד הבא ב-src/index.js כדי שיהיה אפשר להתחבר לקוד ה-CRUD מקובץ ה-JavaScript הראשי ממש לפני הקטע האחרון שמתחיל ב-app.listen(PORT, () => {

const bodyParser = require('body-parser')
app.use(bodyParser.json())
app.use(
 bodyParser.urlencoded({
   extended: true,
 })
)
const db = require("../app/models");
db.sequelize.sync();
require("../app/routes/item.routes")(app);

4. צריך לערוך את הפריסה בקובץ deployment.yaml כדי להוסיף את משתני הסביבה שיספקו את פרטי הקישוריות של מסד הנתונים.

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

    spec:
      containers:
      - name: mynodejsapp
        image: mynodejsapp
        env:
        - name: DB_HOST
          value: ${DB_INSTANCE_IP}        
        - name: DB_PORT
          value: "5432"  
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: username
        - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: gke-cloud-sql-secrets
              key: database

5. החלפת הערך DB_HOST בכתובת של מסד הנתונים שלך

export DB_INSTANCE_IP=$(gcloud sql instances describe mytest-instance \
    --format=json | jq \
    --raw-output ".ipAddresses[].ipAddress")

envsubst < deployment.yaml > deployment.new && mv deployment.new deployment.yaml

פריסה ואימות של אפליקציה

1. בחלונית שבחלק התחתון של Cloud Shell Editor, בוחרים באפשרות Cloud Code ואז בוחרים באפשרות Debug on Kubernetes בחלק העליון של המסך.
2. בסיום ה-build והבדיקות, תופיע בכרטיסייה 'פלט' ההודעה: Resource deployment/mynodejsapp status completed successfully, ובכרטיסיית ה'פלט' תופיע כתובת ה-URL: 'כתובת URL שהועברה מהשירות mynodejsapp: http://localhost:8080'
3. כדאי להוסיף כמה פריטים.

מ-cloudshell Terminal, מריצים את הפקודות שלמטה

URL=localhost:8080
curl -X POST $URL/items -d '{"itemName":"Body Spray", "itemPrice":3.2}' -H "Content-Type: application/json"
curl -X POST $URL/items -d '{"itemName":"Nail Cutter", "itemPrice":2.5}' -H "Content-Type: application/json"

4. כדי לבדוק את בקשת ה-GET, מריצים את $URL/items בדפדפן. אפשר גם להריץ את ה-curl משורת הפקודה

curl -X GET $URL/items

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

curl -X DELETE $URL/items/1

    This throws an error message

{"message":"Could not delete Item with id=[object Object]"}

זיהוי ותיקון הבעיה

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

• אנחנו יודעים שמשהו לא תקין ב-DELETE כי היא לא מחזירה את התוצאה הרצויה. לכן צריך להגדיר את נקודת העצירה (breakpoint) בשיטה itemcontroller.js->exports.delete.
• מריצים שלב אחרי שלב ועוקבים אחרי המשתנים בכל שלב כדי לתעד את הערכים של המשתנים המקומיים בחלון השמאלי.
• כדי לתעד ערכים ספציפיים, כמו request.params, צריך להוסיף את המשתנה הזה לחלון הצפייה.

2. חשוב לשים לב שהערך שהוקצה ל-id הוא undefined. כדי לפתור את הבעיה, משנים את הקוד.

קטע הקוד הקבוע ייראה כך.

// Delete a Item with the specified id in the request
exports.delete = (req, res) => {
    const id = req.params.id;

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

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

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

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

1. מחיקת הקבצים ששימשו בשיעור ה-Lab

cd ~ && rm -rf mynodejsapp && rm -f setup.sh

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