1. סקירה כללית
שיעור ה-Lab הזה להדגים תכונות ויכולות שנועדו לייעל את תהליך הפיתוח של מהנדסי תוכנה שאחראים על פיתוח אפליקציות Java בסביבה בקונטיינרים. פיתוח אופייני של קונטיינרים מחייב את המשתמשים להבין את הפרטים של קונטיינרים ואת תהליך הפיתוח של הקונטיינרים. בנוסף, בדרך כלל מפתחים צריכים לפרוץ את התהליך ולצאת מסביבת הפיתוח המשולבת (IDE) שלהם כדי לבדוק את האפליקציות שלהם ולנפות באגים בסביבות מרוחקות. בעזרת הכלים והטכנולוגיות שמוזכרים במדריך הזה, מפתחים יכולים לעבוד ביעילות עם אפליקציות בקונטיינרים בלי לצאת מסביבת הפיתוח המשולבת (IDE).
מה תלמדו
בשיעור ה-Lab הזה תלמדו שיטות לפיתוח עם קונטיינרים ב-GCP, כולל:
- פיתוח InnerLoop באמצעות Cloud Workstations
- יצירת אפליקציה חדשה לתחילת העבודה עם Java
- להדרכה על תהליך הפיתוח
- פיתוח שירות CRUD מסוג מנוחה פשוט
- אפליקציה לניפוי באגים באשכול GKE
- קישור האפליקציה למסד הנתונים של CloudSQL
2. הגדרה ודרישות
הגדרת סביבה בקצב אישי
- נכנסים למסוף Google Cloud ויוצרים פרויקט חדש או עושים שימוש חוזר בפרויקט קיים. אם אין לכם עדיין חשבון Gmail או חשבון Google Workspace, עליכם ליצור חשבון.
- Project name הוא השם המוצג של המשתתפים בפרויקט. זו מחרוזת תווים שלא משמשת את Google APIs. אפשר לעדכן אותו בכל שלב.
- Project ID הוא ייחודי בכל הפרויקטים ב-Google Cloud ואי אפשר לשנות אותו (אי אפשר לשנות אותו אחרי שמגדירים אותו). מסוף Cloud יוצר מחרוזת ייחודית באופן אוטומטי; בדרך כלל לא מעניין אותך מה זה. ברוב ה-Codelabs תצטרכו להפנות אל מזהה הפרויקט (בדרך כלל הוא מזוהה כ-
PROJECT_ID
). אם המזהה שנוצר לא מוצא חן בעיניך, יש לך אפשרות ליצור מזהה אקראי אחר. לחלופין, אפשר לנסות תבנית משלך ולבדוק אם היא זמינה. לא ניתן לשנות אותו אחרי השלב הזה, והוא יישאר למשך הפרויקט. - לידיעתך, יש ערך שלישי – Project Number (מספר פרויקט), שחלק מממשקי ה-API משתמשים בו. מידע נוסף על כל שלושת הערכים האלה זמין במסמכי התיעוד.
- בשלב הבא צריך להפעיל את החיוב במסוף Cloud כדי להשתמש במשאבים או בממשקי API של Cloud. מעבר ב-Codelab הזה לא אמור לעלות הרבה, אם בכלל. כדי להשבית את המשאבים ולא לצבור חיובים מעבר למדריך הזה, אתם יכולים למחוק את המשאבים שיצרתם או למחוק את הפרויקט כולו. משתמשים חדשים ב-Google Cloud זכאים להצטרף לתוכנית תקופת ניסיון בחינם בשווי 1,200 ש"ח.
הפעלת Cloudshell Editor
שיעור ה-Lab הזה תוכנן ונבדק לשימוש עם Google Cloud Shell Editor. כדי לגשת לכלי העריכה:
- ניגשים לפרויקט Google בכתובת https://console.cloud.google.com.
- בפינה השמאלית העליונה, לוחצים על סמל העורך של Cloud Shell
- חלונית חדשה תיפתח בחלק התחתון של החלון
- לוחצים על הלחצן 'פתיחת העורך'.
- העורך ייפתח בצד שמאל עם כלי חקירה משמאל ועורך באזור המרכזי.
- חלונית טרמינל אמורה להיות זמינה גם בחלק התחתון של המסך
- אם הטרמינל לא פתוח, משתמשים בשילוב המקשים של 'Ctrl+' כדי לפתוח חלון טרמינל חדש
הגדרת gcloud
ב-Cloud Shell, מגדירים את מזהה הפרויקט ואת האזור שבו רוצים לפרוס את האפליקציה. שומרים אותם כמשתנים מסוג PROJECT_ID
ו-REGION
.
export REGION=us-central1
export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)')
שכפול קוד המקור
קוד המקור של שיעור ה-Lab הזה נמצא בסדנה למפתחים של קונטיינרים ב-GoogleCloudPlatform ב-GitHub. משכפלים באמצעות הפקודה שלמטה ומשנים את שם הספרייה.
git clone https://github.com/GoogleCloudPlatform/container-developer-workshop.git
cd container-developer-workshop/labs/spring-boot
הקצאת התשתית שבה נעשה שימוש בשיעור ה-Lab הזה
בשיעור ה-Lab הזה תפרסו קוד ל-GKE ותגשו לנתונים שמאוחסנים במסד נתונים של CloudSQL. סקריפט ההגדרה שבהמשך מכין את התשתית הזו עבורכם. תהליך ההקצאה יימשך יותר מ-25 דקות. צריך להמתין להשלמת הסקריפט לפני שעוברים לקטע הבא.
./setup_with_cw.sh &
אשכול Cloud Workstations
פותחים את Cloud Workstations במסוף Cloud. ממתינים שהאשכול יהיה בסטטוס READY
.
יצירת תצורה של תחנות עבודה
אם הסשן של Cloud Shell התנתק, צריך ללחוץ על Reconnect (התחברות מחדש). ואז מריצים את הפקודה cli של gcloud כדי להגדיר את מזהה הפרויקט. לפני הרצת הפקודה, צריך להחליף את מזהה הפרויקט לדוגמה שבהמשך במזהה הפרויקט ב-qwiklabs.
gcloud config set project qwiklabs-gcp-project-id
כדי ליצור תצורה של Cloud Workstations, מריצים את הסקריפט הבא בטרמינל.
cd ~/container-developer-workshop/labs/spring-boot
./workstation_config_setup.sh
מאמתים את התוצאות בקטע 'הגדרות אישיות'. המעבר לסטטוס READY יימשך 2 דקות.
פותחים את Cloud Workstations במסוף ויוצרים מכונה חדשה.
שינוי השם ל-my-workstation
ובחירה בהגדרה הקיימת: codeoss-java
.
מאמתים את התוצאות בקטע 'תחנות עבודה'.
הפעלה של תחנת העבודה
מפעילים את תחנת העבודה.
אפשר להשתמש בקובצי Cookie של צד שלישי על ידי לחיצה על הסמל בסרגל הכתובות.
לוחצים על "האתר לא פועל?".
לוחצים על "אפשר להשתמש בקובצי Cookie".
ברגע שתושק תחנת העבודה, יופיע סביבת פיתוח משולבת (IDE) של Code OSS. לוחצים על 'סימון כ'בוצע''. בדף 'תחילת העבודה', סביבת הפיתוח המשולבת (IDE) של תחנת העבודה
3. יצירת אפליקציה חדשה לתחילת העבודה עם Java
בקטע זה תיצרו אפליקציה חדשה לגמרי מסוג Java Spring Boot באמצעות אפליקציה לדוגמה שסופקה על ידי spring.io. פותחים חלון Terminal חדש.
שכפול האפליקציה לדוגמה
- יצירת אפליקציה לתחילת פעולה
curl https://start.spring.io/starter.zip -d dependencies=web -d type=maven-project -d javaVersion=17 -d packageName=com.example.springboot -o sample-app.zip
אם ההודעה הזו מופיעה, צריך ללחוץ על הלחצן Allow (אישור), כדי להעתיק את ההדבקה לתחנת העבודה.
- מחלצים את תוכן האפליקציה
unzip sample-app.zip -d sample-app
- פתיחת האפליקציה לדוגמה תיקייה
cd sample-app && code-oss-cloud-workstations -r --folder-uri="$PWD"
הוספת כלי פיתוח לעונת האביב ג'יב
כדי להפעיל את כלי הפיתוח לאתחול אביב, צריך לחפש את pom.xml בסייר בעורך ולפתוח אותו. עכשיו צריך להדביק את הקוד הבא אחרי שורת התיאור שבה כתוב <description>Demo project for Spring Boot</description>
- הוספה של spring-boot-devtools ב-pom.xml
פותחים את הקובץ pom.xml
ברמה הבסיסית (root) של הפרויקט. צריך להוסיף את ההגדרות האישיות הבאות אחרי הרשומה Description
.
pom.xml
<!-- Spring profiles-->
<profiles>
<profile>
<id>sync</id>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
</dependencies>
</profile>
</profiles>
- הפעלת jib-maven-plugin ב-pom.xml
Jib הוא כלי בקוד פתוח של Google ליצירת קונטיינרים של Java שמאפשר למפתחי Java לבנות קונטיינרים באמצעות כלי Java שהם מכירים. Jib הוא כלי מהיר ופשוט ליצירת קובצי אימג' של קונטיינר שמטפל בכל השלבים של אריזת האפליקציה שלכם בקובץ אימג' של קונטיינר. לא צריך לכתוב קובץ Docker או להתקין Docker, והוא משולב ישירות ב-Maven וב-Gradle.
גוללים למטה בקובץ pom.xml
ומעדכנים את הקטע Build
כך שיכלול את הפלאגין של Jib. קטע ה-build צריך להתאים לקטע הבא בסיום התהליך.
pom.xml
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<!-- Jib Plugin-->
<plugin>
<groupId>com.google.cloud.tools</groupId>
<artifactId>jib-maven-plugin</artifactId>
<version>3.2.0</version>
</plugin>
<!-- Maven Resources Plugin-->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<version>3.1.0</version>
</plugin>
</plugins>
</build>
יצירת מניפסטים
Skaffold מספק כלים משולבים שעוזרים לפשט את פיתוח הקונטיינרים. בשלב הזה מפעילים את Skaffold כדי ליצור באופן אוטומטי קובצי YAML בסיסיים ב-Kubernetes. התהליך מנסה לזהות ספריות עם הגדרות של קובץ אימג' בקונטיינר, כמו קובץ Docker, ואז יוצר מניפסט שירות ופריסה לכל אחת מהן.
כדי להתחיל את התהליך, מריצים את הפקודה הבאה ב-Terminal.
- מריצים את הפקודה הבאה בטרמינל
skaffold init --generate-manifests
- כשמוצגת ההודעה:
- משתמשים בחצים כדי להזיז את הסמן אל
Jib Maven Plugin
- כדי לבחור את האפשרות, לוחצים על מקש הרווח.
- יש להקיש על Enter כדי להמשיך
- מזינים 8080 ליציאה
- מזינים y כדי לשמור את ההגדרה.
שני קבצים נוספו לסביבת העבודה skaffold.yaml
ו-deployment.yaml
פלט Skaffold:
עדכון שם האפליקציה
ערכי ברירת המחדל הכלולים בתצורה לא תואמים כרגע לשם האפליקציה שלך. מעדכנים את הקבצים כך שיפנו לשם האפליקציה, במקום לערכי ברירת המחדל.
- שינוי הערכים בהגדרות של Skaffold
- פתיחה של
skaffold.yaml
- בחירת שם התמונה שמוגדר כרגע בתור
pom-xml-image
- לוחצים לחיצה ימנית ובוחרים באפשרות 'שינוי כל המופעים'
- יש להקליד את השם החדש בתור
demo-app
- שינוי רשומות בהגדרות של Kubernetes
- פתיחת קובץ אחד (
deployment.yaml
) - בחירת שם התמונה שמוגדר כרגע בתור
pom-xml-image
- לוחצים לחיצה ימנית ובוחרים באפשרות 'שינוי כל המופעים'
- יש להקליד את השם החדש בתור
demo-app
הפעלת מצב סנכרון אוטומטי
כדי לאפשר חוויית שימוש אופטימלית בטעינה מחדש מתוך הזיכרון, השתמשו בתכונת הסנכרון של Jib. בשלב הזה מגדירים את Skaffold להשתמש בתכונה הזו בתהליך ה-build.
שימו לב שה'סנכרון' הפרופיל שמגדירים בתצורה של Skaffold משתמש ב'סנכרון' של Spring הפרופיל שהגדרתם בשלב הקודם, שבו הפעלתם תמיכה ל-Spring-dev-tools.
- עדכון ההגדרה של Skaffold
בקובץ skaffold.yaml
, צריך להחליף את כל קטע ה-build של הקובץ במפרט הבא. אין לשנות קטעים אחרים בקובץ.
skaffold.yaml
build:
artifacts:
- image: demo-app
jib:
project: com.example:demo
type: maven
args:
- --no-transfer-progress
- -Psync
fromImage: gcr.io/distroless/java17-debian11:debug
sync:
auto: true
הוספה של נתיב ברירת מחדל
יוצרים קובץ בשם HelloController.java
בתיקייה /src/main/java/com/example/springboot/
.
מדביקים את התכנים הבאים בקובץ כדי ליצור נתיב http שמוגדר כברירת מחדל.
HelloController.java
package com.example.springboot;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.beans.factory.annotation.Value;
@RestController
public class HelloController {
@Value("${target:local}")
String target;
@GetMapping("/")
public String hello()
{
return String.format("Hello from your %s environment!", target);
}
}
4. להדרכה על תהליך הפיתוח
בחלק הזה נסביר איך להשתמש בפלאגין של Cloud Code כדי ללמוד על התהליכים הבסיסיים ולאמת את ההגדרה ואת ההגדרה של אפליקציה לתחילת העבודה.
פלטפורמת Cloud Code עובדת בשילוב עם Skaffold כדי לייעל את תהליך הפיתוח. כשפורסים ב-GKE התהליך הזה מתרחש מאחורי הקלעים ומסיר את הפרטים מהתהליך למפתחים. Cloud Code גם משפר את תהליך הפיתוח באמצעות יכולות מסורתיות של ניפוי באגים ו-hotsync לפיתוח מבוסס-קונטיינר.
כניסה ל-Google Cloud
לוחצים על הסמל של Cloud Code ובוחרים באפשרות "Sign in to Google Cloud" (כניסה ל-Google Cloud):
לוחצים על 'המשך לכניסה'.
בודקים את הפלט ב-Terminal ופותחים את הקישור:
מתחברים עם פרטי הכניסה של התלמידים ב-Qwiklabs.
בוחרים באפשרות 'יש אישור':
מעתיקים את קוד האימות וחוזרים לכרטיסייה 'תחנת עבודה'.
מדביקים את קוד האימות ומקישים על Enter.
הוספת אשכול Kubernetes
- הוספת אשכול
- בחירת Google Kubernetes Engine:
- בוחרים פרויקט.
- בוחרים באפשרות 'אשכול ציטוטים' שנוצר בהגדרה הראשונית.
הגדרת מזהה הפרויקט הנוכחי באמצעות cli של gcloud
מעתיקים את מזהה הפרויקט לשיעור ה-Lab הזה מהדף qwiklabs.
מריצים את הפקודה cli של gcloud כדי להגדיר את מזהה הפרויקט. לפני הרצת הפקודה, צריך להחליף את מזהה הפרויקט לדוגמה.
gcloud config set project qwiklabs-gcp-project-id
פלט לדוגמה:
ניפוי באגים ב-Kubernetes
- בחלונית שמימין למטה, בוחרים ב-Cloud Code.
- בחלונית שמופיעה בקטע 'משימות פיתוח', בוחרים באפשרות 'ניפוי באגים ב-Kubernetes'.
גוללים למטה אם האפשרות לא מוצגת.
- צריך לבחור באפשרות 'כן' כדי להשתמש בהקשר הנוכחי.
- בוחרים באפשרות 'אשכול ציטוטים' שנוצר במהלך ההגדרה הראשונית.
- בוחרים באפשרות Container Repository.
- צריך לבחור בכרטיסייה 'פלט' בחלונית התחתונה כדי לראות את ההתקדמות וההתראות
- בוחרים באפשרות Kubernetes: Run/Debug - Detailed (Kubernetes: הרצה/ניפוי באגים - מפורט). בתפריט הנפתח של הערוץ משמאל כדי להציג פרטים נוספים ויומנים בסטרימינג בשידור חי ממאגרי התגים
ממתינים לפריסת האפליקציה.
- לבדוק את האפליקציה שנפרסה ב-GKE ב-Cloud Console.
- כדי לחזור לתצוגה הפשוטה, בוחרים באפשרות 'Kubernetes: הרצה/ניפוי באגים'. מהתפריט הנפתח בכרטיסייה OUTPUT.
- בסיום ה-build והבדיקות, תופיע בכרטיסייה 'פלט' ההודעה:
Resource deployment/demo-app status completed successfully
, ובכרטיסיית ה'פלט' תופיע כתובת ה-URL: 'כתובת ה-URL שהועברה מאפליקציית ההדגמה של השירות: http://localhost:8080' - בטרמינל של Cloud Code, מעבירים את העכבר מעל כתובת ה-URL שמופיעה בפלט (http://localhost:8080) ואז בטיפ הכלי שמופיע בוחרים באפשרות 'מעקב אחר קישור'.
תיפתח כרטיסייה חדשה ותוכלו לראות את הפלט למטה:
שימוש בנקודות עצירה (breakpoint)
- פתיחת האפליקציה
HelloController.java
שנמצאת בכתובת/src/main/java/com/example/springboot/HelloController.java
- צריך לאתר את הצהרת ההחזרה של נתיב הבסיס –
return String.format("Hello from your %s environment!", target);
- כדי להוסיף נקודת עצירה לשורה הזו, לוחצים על הרווח הריק שמימין למספר השורה. יוצג אינדיקטור אדום כדי לציין שנקודת העצירה הוגדרה
- טוענים מחדש את הדפדפן ומציינים שהכלי לניפוי באגים עוצר את התהליך בנקודת העצירה (breakpoint) ומאפשר לכם לחקור את המשתנים והמצב של האפליקציה שרצה מרחוק ב-GKE
- לוחצים למטה בקטע המשתנים עד שמוצאים את האפשרות 'Target' (יעד) מותאם אישית.
- בודקים את הערך הנוכחי כ'local'
- לוחצים לחיצה כפולה על שם המשתנה target (יעד) ובחלון הקופץ,
משנים את הערך ל-Cloud Workstations.
- לוחצים על הלחצן 'המשך' בלוח הבקרה של ניפוי הבאגים.
- בודקים את התשובה בדפדפן, שמציגה עכשיו את הערך המעודכן שהזנתם.
- מסירים את נקודת העצירה בלחיצה על האינדיקטור האדום שמימין למספר השורה. כך הקוד לא יפסיק לפעול בשורה הזו כשתתקדמו בשיעור ה-Lab הזה.
טעינה מחדש מתוך הזיכרון (hot Reload)
- משנים את ההצהרה כך שתחזיר ערך אחר, כמו 'שלום מקוד %s'.
- הקובץ נשמר באופן אוטומטי ומסונכרן עם הקונטיינרים המרוחקים ב-GKE
- מרעננים את הדפדפן כדי לראות את התוצאות המעודכנות.
- כדי להפסיק את פעילות ניפוי הבאגים, לוחצים על הריבוע האדום בסרגל הכלים של ניפוי הבאגים
בוחרים באפשרות 'כן, אני רוצה לנקות אחרי כל הפעלה'.
5. פיתוח שירות CRUD מסוג מנוחה פשוט
בשלב הזה האפליקציה מוגדרת במלואה לפיתוח בקונטיינרים, והסברתם על תהליך הפיתוח הבסיסי באמצעות Cloud Code. בחלקים הבאים תתרגלו את מה שלמדתם על ידי הוספת נקודות קצה של שירות REST שמתחברות למסד נתונים מנוהל ב-Google Cloud.
הגדרת יחסי תלות
הקוד של האפליקציה משתמש במסד נתונים כדי לשמור את הנתונים של שירות השאר. כדי לוודא שיחסי התלות זמינים, צריך להוסיף את הערכים הבאים ב-pom.xl
- פותחים את הקובץ
pom.xml
ומוסיפים את הפרטים הבאים לקטע של יחסי התלות בתצורה
pom.xml
<!-- Database dependencies-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.postgresql</groupId>
<artifactId>postgresql</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.flywaydb</groupId>
<artifactId>flyway-core</artifactId>
</dependency>
<dependency>
<groupId>javax.persistence</groupId>
<artifactId>javax.persistence-api</artifactId>
<version>2.2</version>
</dependency>
שירות REST בפורמט REST
Quote.java
יוצרים קובץ בשם Quote.java
ב-/src/main/java/com/example/springboot/
ומעתיקים את הקוד שבהמשך. מגדיר את מודל הישות לאובייקט Quote שנעשה בו שימוש באפליקציה.
package com.example.springboot;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import java.util.Objects;
@Entity
@Table(name = "quotes")
public class Quote
{
@Id
@Column(name = "id")
private Integer id;
@Column(name="quote")
private String quote;
@Column(name="author")
private String author;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getQuote() {
return quote;
}
public void setQuote(String quote) {
this.quote = quote;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Quote quote1 = (Quote) o;
return Objects.equals(id, quote1.id) &&
Objects.equals(quote, quote1.quote) &&
Objects.equals(author, quote1.author);
}
@Override
public int hashCode() {
return Objects.hash(id, quote, author);
}
}
QuoteRepository.java
יוצרים קובץ בשם QuoteRepository.java
בכתובת src/main/java/com/example/springboot
ומעתיקים את הקוד הבא
package com.example.springboot;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
public interface QuoteRepository extends JpaRepository<Quote,Integer> {
@Query( nativeQuery = true, value =
"SELECT id,quote,author FROM quotes ORDER BY RANDOM() LIMIT 1")
Quote findRandomQuote();
}
הקוד הזה משתמש ב-JPA לשמירת הנתונים. הכיתה מרחיבה את ממשק Spring JPARepository
ומאפשרת ליצור קוד בהתאמה אישית. בקוד שהוספת, שיטה מותאמת אישית findRandomQuote
.
QuoteController.java
כדי לחשוף את נקודת הקצה של השירות, מחלקה QuoteController
תספק את הפונקציונליות הזו.
יצירת קובץ בשם QuoteController.java
בכתובת src/main/java/com/example/springboot
והעתקה של התוכן הבא
package com.example.springboot;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class QuoteController {
private final QuoteRepository quoteRepository;
public QuoteController(QuoteRepository quoteRepository) {
this.quoteRepository = quoteRepository;
}
@GetMapping("/random-quote")
public Quote randomQuote()
{
return quoteRepository.findRandomQuote();
}
@GetMapping("/quotes")
public ResponseEntity<List<Quote>> allQuotes()
{
try {
List<Quote> quotes = new ArrayList<Quote>();
quoteRepository.findAll().forEach(quotes::add);
if (quotes.size()==0 || quotes.isEmpty())
return new ResponseEntity<List<Quote>>(HttpStatus.NO_CONTENT);
return new ResponseEntity<List<Quote>>(quotes, HttpStatus.OK);
} catch (Exception e) {
System.out.println(e.getMessage());
return new ResponseEntity<List<Quote>>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
@PostMapping("/quotes")
public ResponseEntity<Quote> createQuote(@RequestBody Quote quote) {
try {
Quote saved = quoteRepository.save(quote);
return new ResponseEntity<Quote>(saved, HttpStatus.CREATED);
} catch (Exception e) {
System.out.println(e.getMessage());
return new ResponseEntity<Quote>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
@PutMapping("/quotes/{id}")
public ResponseEntity<Quote> updateQuote(@PathVariable("id") Integer id, @RequestBody Quote quote) {
try {
Optional<Quote> existingQuote = quoteRepository.findById(id);
if(existingQuote.isPresent()){
Quote updatedQuote = existingQuote.get();
updatedQuote.setAuthor(quote.getAuthor());
updatedQuote.setQuote(quote.getQuote());
return new ResponseEntity<Quote>(updatedQuote, HttpStatus.OK);
} else {
return new ResponseEntity<Quote>(HttpStatus.NOT_FOUND);
}
} catch (Exception e) {
System.out.println(e.getMessage());
return new ResponseEntity<Quote>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
@DeleteMapping("/quotes/{id}")
public ResponseEntity<HttpStatus> deleteQuote(@PathVariable("id") Integer id) {
Optional<Quote> quote = quoteRepository.findById(id);
if (quote.isPresent()) {
quoteRepository.deleteById(id);
return new ResponseEntity<>(HttpStatus.NO_CONTENT);
} else {
return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
}
}
}
הוספת הגדרות של מסד נתונים
application.yaml
הוספת תצורה למסד הנתונים בקצה העורפי שהשירות ניגש אליו. עורכים (או יוצרים, אם לא קיים) את הקובץ בשם application.yaml
בקטע src/main/resources
ומוסיפים הגדרת Spring עם פרמטרים לקצה העורפי.
target: local
spring:
config:
activate:
on-profile: cloud-dev
datasource:
url: 'jdbc:postgresql://${DB_HOST:127.0.0.1}/${DB_NAME:quote_db}'
username: '${DB_USER:user}'
password: '${DB_PASS:password}'
jpa:
properties:
hibernate:
jdbc:
lob:
non_contextual_creation: true
dialect: org.hibernate.dialect.PostgreSQLDialect
hibernate:
ddl-auto: update
הוספת העברה של מסדי נתונים
יצירת תיקיות db/migration
תחת src/main/resources
יוצרים קובץ SQL: V1__create_quotes_table.sql
מדביקים בקובץ את התכנים הבאים
V1__create_quotes_table.sql
CREATE TABLE quotes(
id INTEGER PRIMARY KEY,
quote VARCHAR(1024),
author VARCHAR(256)
);
INSERT INTO quotes (id,quote,author) VALUES (1,'Never, never, never give up','Winston Churchill');
INSERT INTO quotes (id,quote,author) VALUES (2,'While there''s life, there''s hope','Marcus Tullius Cicero');
INSERT INTO quotes (id,quote,author) VALUES (3,'Failure is success in progress','Anonymous');
INSERT INTO quotes (id,quote,author) VALUES (4,'Success demands singleness of purpose','Vincent Lombardi');
INSERT INTO quotes (id,quote,author) VALUES (5,'The shortest answer is doing','Lord Herbert');
הגדרת Kubernetes
התוספות הבאות לקובץ deployment.yaml
מאפשרות לאפליקציה להתחבר למכונות של CloudSQL.
- TARGET – מגדיר את המשתנה כדי לציין את הסביבה שבה האפליקציה מופעלת
- SPRING_PROFILES_ACTIVE – הצגת פרופיל ה-Spring הפעיל, שיוגדר כ-
cloud-dev
- DB_HOST – כתובת ה-IP הפרטית של מסד הנתונים, שצוינה כאשר מופע מסד הנתונים נוצר או על ידי לחיצה על
SQL
בתפריט הניווט של מסוף Google Cloud – יש לשנות את הערך ! - DB_USER ו-DB_PASS – כפי שהוגדרו בתצורה של מכונת CloudSQL, מאוחסנים כסוד ב-GCP
מעדכנים אתDeploy.yaml בתוכן הבא.
deployment.yaml
apiVersion: v1
kind: Service
metadata:
name: demo-app
labels:
app: demo-app
spec:
ports:
- port: 8080
protocol: TCP
clusterIP: None
selector:
app: demo-app
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: demo-app
labels:
app: demo-app
spec:
replicas: 1
selector:
matchLabels:
app: demo-app
template:
metadata:
labels:
app: demo-app
spec:
containers:
- name: demo-app
image: demo-app
env:
- name: PORT
value: "8080"
- name: TARGET
value: "Local Dev - CloudSQL Database - K8s Cluster"
- name: SPRING_PROFILES_ACTIVE
value: cloud-dev
- 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
מחליפים את הערך DB_HOST בכתובת של מסד הנתונים על ידי הרצת הפקודות הבאות בטרמינל:
export DB_INSTANCE_IP=$(gcloud sql instances describe quote-db-instance \
--format=json | jq \
--raw-output ".ipAddresses[].ipAddress")
envsubst < deployment.yaml > deployment.new && mv deployment.new deployment.yaml
פותחים אתDeploy.yaml ומוודאים שערך DB_HOST עודכן בכתובת IP של מכונה.
פריסה ואימות של אפליקציה
- בחלונית שבחלק התחתון של Cloud Shell Editor, בוחרים באפשרות Cloud Code ואז בוחרים באפשרות Debug ב-Kubernetes בחלק העליון של המסך.
- בסיום ה-build והבדיקות, בכרטיסייה 'פלט' מופיע הכיתוב:
Resource deployment/demo-app status completed successfully
, וכתובת ה-URL מופיעה: 'כתובת URL שהועברה מאפליקציית ההדגמה של השירות: http://localhost:8080'. שימו לב שלפעמים היציאה עשויה להיות שונה כמו 8081. במקרה כזה, מגדירים את הערך המתאים. הגדרת הערך של כתובת URL בטרמינל
export URL=localhost:8080
- הצגת ציטוטים אקראיים
מ-Terminal, מריצים את הפקודה הבאה מספר פעמים מול נקודת הקצה במירכאות אקראיות. צפייה בשיחה חוזרת שמחזירה ציטוטים שונים
curl $URL/random-quote | jq
- הוספת ציטוט
יוצרים הצעת מחיר חדשה, עם id=6 באמצעות הפקודה שלמטה ובודקים את הבקשה חוזרת
curl -H 'Content-Type: application/json' -d '{"id":"6","author":"Henry David Thoreau","quote":"Go confidently in the direction of your dreams! Live the life you have imagined"}' -X POST $URL/quotes
- מחיקת ציטוט
עכשיו מוחקים את הציטוט שהוספתם באמצעות שיטת המחיקה ובודקים את קוד התגובה HTTP/1.1 204
.
curl -v -X DELETE $URL/quotes/6
- שגיאה בחיבור לשרת
מצב של שגיאה יכול להיווצר על ידי הרצת הבקשה האחרונה לאחר שהרשומה כבר נמחקה.
curl -v -X DELETE $URL/quotes/6
שימו לב שהתשובה מחזירה HTTP:500 Internal Server Error
.
ניפוי באגים באפליקציה
בקטע הקודם נמצא מצב שגיאה באפליקציה כשניסית למחוק רשומה שלא נמצאת במסד הנתונים. בקטע הזה תגדירו נקודת עצירה (breakpoint) לאתר את הבעיה. השגיאה אירעה בפעולה DELETE, לכן עליך לעבוד עם המחלקה QuoteController.
- פתיחה של
src/main/java/com/example/springboot/QuoteController.java
- חיפוש השיטה
deleteQuote()
- מאתרים את הקו:
Optional<Quote> quote = quoteRepository.findById(id);
- מגדירים נקודת עצירה בשורה הזו על ידי לחיצה על הרווח הריק שמימין למספר השורה.
- יופיע אינדיקטור אדום שמציין שנקודת העצירה (breakpoint) מוגדרת
- מריצים שוב את הפקודה
delete
curl -v -X DELETE $URL/quotes/6
- כדי לחזור לתצוגת ניפוי הבאגים, לוחצים על הסמל בעמודה הימנית.
- חשוב לוודא ששורת ניפוי הבאגים שנעצרה במחלקה QuoteController.
- בכלי לניפוי באגים, לוחצים על הסמל
step over
- שימו לב שקוד מחזיר ללקוח שגיאת שרת פנימית (HTTP 500) שאינה אידיאלית.
Trying 127.0.0.1:8080... * Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0) > DELETE /quotes/6 HTTP/1.1 > Host: 127.0.0.1:8080 > User-Agent: curl/7.74.0 > Accept: */* > * Mark bundle as not supporting multiuse < HTTP/1.1 500 < Content-Length: 0 < Date: < * Connection #0 to host 127.0.0.1 left intact
עדכון הקוד
הקוד שגוי ויש לארגן מחדש את הבלוק else
כדי לשלוח חזרה קוד סטטוס HTTP 404 לא נמצא.
מתקנים את השגיאה.
- כשסשן ניפוי הבאגים עדיין פועל, השלם את הבקשה על ידי לחיצה על הלחצן "המשך". בלוח הבקרה של ניפוי הבאגים.
- בשלב הבא, משנים את הבלוק
else
לקוד:
else {
return new ResponseEntity<HttpStatus>(HttpStatus.NOT_FOUND);
}
השיטה אמורה להיראות כך:
@DeleteMapping("/quotes/{id}") public ResponseEntity<HttpStatus> deleteQuote(@PathVariable("id") Integer id) { Optional<Quote> quote = quoteRepository.findById(id); if (quote.isPresent()) { quoteRepository.deleteById(id); return new ResponseEntity<>(HttpStatus.NO_CONTENT); } else { return new ResponseEntity<HttpStatus>(HttpStatus.NOT_FOUND); } }
- הרצה מחדש של פקודת המחיקה
curl -v -X DELETE $URL/quotes/6
- עוברים על הכלי לניפוי באגים ובודקים את השגיאה 'HTTP 404 Not Found' שהוחזרה למתקשר.
Trying 127.0.0.1:8080... * Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0) > DELETE /quotes/6 HTTP/1.1 > Host: 127.0.0.1:8080 > User-Agent: curl/7.74.0 > Accept: */* > * Mark bundle as not supporting multiuse < HTTP/1.1 404 < Content-Length: 0 < Date: < * Connection #0 to host 127.0.0.1 left intact
- כדי להפסיק את פעילות ניפוי הבאגים, לוחצים על הריבוע האדום בסרגל הכלים של ניפוי הבאגים
6. מזל טוב
מעולה! בשיעור ה-Lab הזה יצרתם מאפס אפליקציית Java חדשה והגדרתם אותה לעבוד ביעילות עם קונטיינרים. לאחר מכן פרסתם את האפליקציה וביצעתם ניפוי באגים באשכול GKE מרוחק, בהתאם לתהליך הפיתוח של האפליקציה בסטאק אפליקציות מסורתי.
מה למדת
- פיתוח InnerLoop באמצעות Cloud Workstations
- יצירת אפליקציה חדשה לתחילת העבודה עם Java
- להדרכה על תהליך הפיתוח
- פיתוח שירות CRUD REST פשוט
- אפליקציה לניפוי באגים באשכול GKE
- קישור האפליקציה למסד הנתונים של CloudSQL