סדנת עיצוב של אפליקציות

1. מבוא

תאריך העדכון האחרון: 1 בנובמבר 2024

איך מעבירים אפליקציית PHP ישנה ל-Google Cloud?

(📽️ צפו בסרטון מבוא של 7 דקות ל-Codelab הזה)

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

בסדנה הזו תלמדו:

  1. העברת אפליקציית ה-PHP לקונטיינר.
  2. מעבר לשירות מנוהל של מסד נתונים (Cloud SQL).
  3. פורסים ב-Cloud Run (חלופה ל-GKE או ל-Kubernetes שלא דורשת פעולות).
  4. לאבטח את האפליקציה באמצעות ניהול זהויות והרשאות גישה (IAM) ו-Secret Manager.
  5. הגדרת צינור עיבוד נתונים של CI/CD באמצעות Cloud Build. אפשר לחבר את Cloud Build למאגר Git שמתארח אצל ספקי Git פופולריים כמו GitHub או GitLab, ולהפעיל אותו בכל דחיפה ל-main, למשל.
  6. לארח את תמונות האפליקציה ב-Cloud Storage. כדי לעשות את זה, צריך להשתמש ב-mounting, ובלי צורך בקוד כדי לשנות את האפליקציה.
  7. הצגת פונקציונליות של AI גנרטיבי באמצעות Gemini, שמנוהל באמצעות Cloud Functions (ללא שרת).
  8. הכירו את יעדי ה-SLO והפעילו את האפליקציה החדשה והרעננה שלכם.

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

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

מידע על האפליקציה

האפליקציה (קוד, בכפוף לרישיון MIT) שתפצלו היא אפליקציית PHP 5.7 בסיסית עם אימות MySQL. הרעיון המרכזי של האפליקציה הוא לספק פלטפורמה שבה המשתמשים יכולים להעלות תמונות, ולאדמינים יש אפשרות לתייג תמונות בלתי הולמות. באפליקציה יש שתי טבלאות:

  • משתמשים. הוא מגיע עם אדמינים מוגדרים מראש. אנשים חדשים יכולים להירשם.
  • תמונות Google. התבנית כוללת כמה תמונות לדוגמה. משתמשים שמחוברים לחשבון יכולים להעלות תמונות חדשות. אנחנו נוסיף כאן קצת קסם.

המטרה

אנחנו רוצים לעשות מודרניזציה לאפליקציה הישנה כדי להעביר אותה ל-Google Cloud. נשתמש בכלים ובשירותים שלה כדי לשפר את המדרגיות, להגביר את האבטחה, להפוך את ניהול התשתית לאוטומטי ולשלב תכונות מתקדמות כמו עיבוד תמונות, מעקב ומאגר נתונים באמצעות שירותים כמו Cloud SQL,‏ Cloud Run,‏ Cloud Build,‏ Secret Manager ועוד.

445f7a9ae37e9b4d.png

חשוב מכך, אנחנו רוצים לעשות את זה שלב אחר שלב כדי שתוכלו ללמוד מהו תהליך החשיבה מאחורי כל שלב, ובדרך כלל כל שלב פותח אפשרויות חדשות לשלבים הבאים (לדוגמה: מודולים 2 -> 3, ו-6 -> 7).

עדיין לא השתכנעת? כדאי לצפות בסרטון הזה ב-YouTube (באורך 7 דקות).

מה תצטרכו

  • מחשב עם דפדפן, שמחובר לאינטרנט.
  • קרדיטים ל-GCP. השלב הבא
  • תשתמשו ב-Cloud Shell. הוא כולל את כל הפקודות שצריך להתקין מראש ו-IDE.
  • חשבון GitHub. אתם צריכים את זה כדי להסתעף מהקוד המקורי 🧑🏻‍💻 gdgpescara/app-mod-workshop עם מאגר Git משלכם. זה נדרש כדי שיהיה לכם צינור עיבוד נתונים משלכם של CI/CD (ביצוע אוטומטי -> build -> פריסה)

כאן אפשר למצוא פתרונות לדוגמה:

הסדנה הזו מיועדת להשלמה ב-Cloud Shell (בדפדפן).

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

2. הגדרת קרדיט ופיצול (Fork)

6dafc658860c0ce5.png

מימוש הקרדיט ל-GCP והגדרת סביבת GCP [אופציונלי]

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

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

bd7548f78689db0b.png

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

6c82aebcb9f5cd47.png

חשוב לקשר את הפרויקט החדש לחשבון לחיוב של תקופת הניסיון ב-GCP, באופן הבא:

f202527d254893fb.png

הכול מוכן לשימוש ב-Google Cloud Platform. אם אתם מתחילים או שאתם פשוט רוצים לעשות הכול בסביבת ענן, אתם יכולים לגשת ל-Cloud Shell ולכלי העריכה שלו באמצעות הלחצן הבא בפינה הימנית העליונה, כמו שמוצג למטה.

7d732d7bf0deb12e.png

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

לא נבחר (לא טוב):

c2ffd36a781b276a.png

נבחר (טוב):

594563c158f4f590.png

יצירת עותק של האפליקציה מ-GitHub

  1. עוברים לאפליקציית ההדגמה: https://github.com/gdgpescara/app-mod-workshop
  2. לוחצים על 🍴 (יצירת עותק).
  3. אם אין לכם חשבון GitHub, אתם צריכים ליצור חשבון חדש.
  4. עורכים את מה שרוצים.

734e51bfc29ee5df.png

  1. משכפלים את קוד האפליקציה באמצעות
  2. git clone https://github.com/YOUR-GITHUB-USER/YOUR-REPO-NAME
  1. פותחים את תיקיית הפרויקט המשוכפל בעורך המועדף. אם בחרתם ב-Cloud Shell, אתם יכולים לעשות את זה בלחיצה על Open Editor, כמו שמוצג למטה.

40f5977ea4c1d1cb.png

כמו שמוצג בתמונה הבאה, יש לכם את כל מה שצריך בעורך של Google Cloud Shell:

a4e5ffb3e9a35e84.png

כדי לעשות את זה, לוחצים על Open Folder (פתיחת תיקייה) ובוחרים את התיקייה, כנראה app-mod-workshop בתיקיית הבית.

3. מודול 1: יצירת מכונה של SQL

645902e511a432a6.png

יצירת מכונה של Google Cloud SQL

אפליקציית ה-PHP שלנו תתחבר למסד נתונים של MySQL, ולכן אנחנו צריכים לשכפל אותו ל-Google Cloud כדי לבצע העברה חלקה. ‫Cloud SQL הוא הפתרון המושלם, כי הוא מאפשר להריץ מסד נתונים מנוהל של MySQL בענן. ככה עושים את זה:

  1. נכנסים לדף Cloud SQL: ‏ https://console.cloud.google.com/sql/instances
  2. לוחצים על "Create Instance".
  3. מפעילים את ה-API (אם צריך). התהליך עשוי להימשך כמה שניות.
  4. בוחרים באפשרות MySQL.
  5. (אנחנו מנסים להשיג לך את הגרסה הכי זולה, כדי שהיא תחזיק מעמד יותר זמן):
  • מהדורה: Enterprise
  • הגדרה קבועה מראש: פיתוח (ניסינו את ארגז החול וזה לא עבד)
  • גרסת Mysql:‏ 5.7 (וואו, ד"ש מהעבר!)
  1. מזהה המכונה: בוחרים באפשרות appmod-phpapp (אם משנים את זה, צריך לזכור לשנות גם סקריפטים ופתרונות עתידיים בהתאם).
  2. סיסמה: מה שרוצים, אבל צריך לרשום אותה בתור CLOUDSQL_INSTANCE_PASSWORD
  3. אזור: צריך לבחור את אותו אזור שנבחר לשאר האפליקציה (למשל, מילאנו = europe-west8)
  4. זמינות לפי אזור: אזור אחד (אנחנו חוסכים כסף בשביל ההדגמה)

לוחצים על הכפתור Create Instance כדי לפרוס את מסד הנתונים של Cloud SQL. ⌛התהליך נמשך כ-10 דקות⌛. בינתיים, ממשיכים לקרוא את המסמכים. אפשר גם להתחיל לפתור את המודול הבא ("הכנסת אפליקציית PHP לקונטיינר"), כי אין לו תלות במודול הזה בחלק הראשון (עד שמתקנים את החיבור למסד הנתונים).

הערה. העלות של המכונה הזו היא כ-7$ ליום. חשוב להפריד אותו אחרי הסדנה.

יצירת מסד נתונים ומשתמש של image_catalog ב-Cloud SQL

פרויקט האפליקציה כולל תיקייה בשם db/ שמכילה שני קובצי SQL:

  1. ‫01_schema.sql: מכיל קוד SQL ליצירת שתי טבלאות שמכילות נתונים של משתמשים ותמונות.
  2. ‫02_seed.sql: מכיל קוד SQL כדי להזין נתונים בטבלאות שנוצרו קודם.

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

  1. פותחים את המכונה ולוחצים על הכרטיסייה Databases:
  2. לוחצים על "Create Database" (יצירת מסד נתונים).
  3. קוראים לו image_catalog (כמו בהגדרת האפליקציה ב-PHP).

997ef853e5ebd857.png

ואז אנחנו יוצרים את המשתמש במסד הנתונים. כך נוכל לאמת את מסד הנתונים image_catalog.

  1. עכשיו לוחצים על הכרטיסייה משתמשים.
  2. לוחצים על "הוספת חשבון משתמש".
  3. משתמש: בוא ניצור אחד:
  • שם המשתמש/ת: appmod-phpapp-user
  • סיסמה: בוחרים סיסמה שקל לזכור או לוחצים על "יצירה".
  • משאירים את האפשרות Allow any host (%)‎ (אישור כל מארח (%)).
  1. לוחצים על "הוספה".

פותחים את מסד הנתונים לכתובות IP מוכרות.

חשוב לזכור שכל מסדי הנתונים ב-Cloud SQL נוצרים "מבודדים". צריך להגדיר במפורש רשת שאפשר יהיה לגשת ממנה.

  1. לוחצים על המכונה.
  2. פותחים את התפריט "חיבורים".
  3. לוחצים על הכרטיסייה "רשת".
  4. לוחצים על Authorized networks (רשתות מורשות). עכשיו מוסיפים רשת (כלומר, רשת משנה).
  • בינתיים, נבחר הגדרות מהירות אך לא מאובטחות כדי לאפשר לאפליקציה לפעול. יכול להיות שתרצו להגביל אותה מאוחר יותר לכתובות ה-IP שאתם סומכים עליהן:
  • שם: "כולם בעולם – לא מאובטח".
  • רשת: "0.0.0.0/0" (הערה: זה החלק הלא מאובטח!)
  • לוחצים על "סיום".
  1. לוחצים על "שמירה".

אמור להופיע משהו כזה:

5ccb9062a7071964.png

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

הגיע הזמן לבדוק את החיבור למסד הנתונים

בואו נבדוק אם המשתמש image_catalog שיצרנו קודם עובד.

נכנסים ל-Cloud SQL Studio בתוך המכונה ומזינים את מסד הנתונים, המשתמש והסיסמה לאימות, כמו שמוצג כאן:

d56765c6154c11a4.png

עכשיו, אחרי שנכנסתם, אתם יכולים לפתוח את עורך ה-SQL ולעבור לחלק הבא.

ייבוא מסד הנתונים מבסיס הקוד

משתמשים בעורך ה-SQL כדי לייבא את הטבלאות של image_catalog עם הנתונים שלהן. מעתיקים את קוד ה-SQL מהקבצים במאגר (‎01_schema.sql ואז ‎02_seed.sql) ומריצים אותם אחד אחרי השני לפי הסדר.

אחרי זה אמורות להופיע שתי טבלאות ב-image_catalog, ‏users ו-images, כמו שמוצג כאן:

65ba01e4c6c2dac0.png

כדי לבדוק את זה, אפשר להריץ את הפקודה הבאה בעורך: select * from images;

חשוב גם לרשום את כתובת ה-IP הציבורית של מכונת Cloud SQL, כי תצטרכו אותה בהמשך. כדי לקבל את כתובת ה-IP, נכנסים לדף הראשי של המכונה של Cloud SQL בקטע Overview. (סקירה כללית > התחברות למכונה הזו > כתובת IP ציבורית).

4. מודול 2: הפיכת אפליקציית PHP לקונטיינר

e7f0e9979d8805f5.png

אנחנו רוצים לפתח את האפליקציה הזו לענן.

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

יש כמה דרכים לארוז אותו:

  • Docker. השיטה הזו פופולרית מאוד, אבל די מורכב להגדיר אותה בצורה נכונה.
  • Buildpacks. פחות פופולרי, אבל נוטה "לנחש אוטומטית" מה לבנות ומה להריץ. לרוב זה פשוט עובד.

בסדנה הזו נניח שאתם משתמשים ב-Docker.

אם בחרתם להשתמש ב-Cloud Shell, זה הזמן לפתוח אותו מחדש (לוחצים על הפינה השמאלית העליונה של מסוף Cloud).

ec6a6b90b39e03e.png

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

6999b906c0dedeb7.png

Docker

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

אנחנו רוצים לפרוס את האפליקציה בקונטיינר ב-Cloud Run, אז כדאי לעיין במסמך התיעוד הזה. איך אפשר להעביר אותו מ-PHP 8 ל-PHP 5.7? אולי Gemini יכול לעזור לך. לחלופין, אפשר להשתמש בגרסה המוכנה הזו:

# Use the official PHP image: https://hub.docker.com/_/php
FROM php:5.6-apache

# Configure PHP for Cloud Run.
# Precompile PHP code with opcache.
# Install PHP's extension for MySQL
RUN docker-php-ext-install -j "$(nproc)" opcache mysqli pdo pdo_mysql && docker-php-ext-enable pdo_mysql

RUN set -ex; \
  { \
    echo "; Cloud Run enforces memory & timeouts"; \
    echo "memory_limit = -1"; \
    echo "max_execution_time = 0"; \
    echo "; File upload at Cloud Run network limit"; \
    echo "upload_max_filesize = 32M"; \
    echo "post_max_size = 32M"; \
    echo "; Configure Opcache for Containers"; \
    echo "opcache.enable = On"; \
    echo "opcache.validate_timestamps = Off"; \
    echo "; Configure Opcache Memory (Application-specific)"; \
    echo "opcache.memory_consumption = 32"; \
  } > "$PHP_INI_DIR/conf.d/cloud-run.ini"

# Copy in custom code from the host machine.
WORKDIR /var/www/html

COPY . .

# Setup the PORT environment variable in Apache configuration files: https://cloud.google.com/run/docs/reference/container-contract#port
ENV PORT=8080

# Tell Apache to use 8080 instead of 80.
RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf

# Note: This is quite insecure and opens security breaches. See last chapter for hardening ideas.
# Uncomment at your own risk:
#RUN chmod 777 /var/www/html/uploads/

# Configure PHP for development.
# Switch to the production php.ini for production operations.
# RUN mv "$PHP_INI_DIR/php.ini-production" "$PHP_INI_DIR/php.ini"
# https://github.com/docker-library/docs/blob/master/php/README.md#configuration
RUN mv "$PHP_INI_DIR/php.ini-development" "$PHP_INI_DIR/php.ini"

# Expose the port
EXPOSE 8080

הגרסה האחרונה של Dockerfile זמינה כאן.

כדי לבדוק את האפליקציה באופן מקומי, צריך לשנות את הקובץ config.php כך שאפליקציית ה-PHP תתחבר למסד הנתונים של MySQL שזמין ב-Google CloudSQL. בהתאם למה שהגדרתם קודם, מלאו את הפרטים החסרים:

<?php
// Database configuration
$db_host = '____________';
$db_name = '____________';
$db_user = '____________';
$db_pass = '____________';

try {
    $pdo = new PDO("mysql:host=$db_host;dbname=$db_name", $db_user, $db_pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    die("Errore di connessione: " . $e->getMessage());
}

session_start();
?>
  • ‫DB_HOST היא כתובת ה-IP הציבורית של Cloud SQL, ואפשר למצוא אותה במסוף SQL:

bd27071bf450a8d0.png

  • DB_NAME לא אמור להשתנות: image_catalog
  • DB_USER צריך להיות appmod-phpapp-user
  • DB_PASS הוא משהו שבחרתם. מגדירים אותו במירכאות בודדות ומוסיפים תווי בריחה לפי הצורך.

אפשר גם לתרגם את הקטעים הקצרים באיטלקית 🇮🇹 לאנגלית בעזרת Gemini!

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

אם עדיין לא התקנתם את Docker, אתם יכולים להתקין אותו (קישור). אם אתם משתמשים ב-Cloud Shell, אתם לא צריכים את זה (מגניב, נכון?).

עכשיו נסו ליצור ולהריץ את אפליקציית ה-PHP בקונטיינר באמצעות הפקודות המתאימות של docker build ו-docker run.

# Build command - don't forget the final . This works if Dockerfile is inside the code folder:
$ docker build -t my-php-app-docker .   

# Local Run command: most likely ports will be 8080:8080
$ docker run -it -p <CONTAINER_PORT>:<LOCAL_MACHINE_PORT> my-php-app-docker

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

33a24673f4550454.png

בדיקת התוצאה בדפדפן

עכשיו האפליקציה אמורה להיראות בערך כך:

2718ece96b1f18b6.png

אם תתחברו עם Admin/admin123, תראו משהו כזה.

68b62048c2e86aea.png

מעולה!!! חוץ מהטקסט באיטלקית, זה עובד! 🎉🎉🎉

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

e22f45b79bab86e1.png

כדאי לנסות שוב, התשובה קרובה.

שמירה ב-Artifact Registry [אופציונלי]

בשלב הזה, אמורה להיות לכם אפליקציית PHP פעילה בקונטיינר שמוכנה לפריסה בענן. בשלב הבא, אנחנו צריכים מקום בענן כדי לאחסן את קובץ האימג' של Docker ולהפוך אותו לנגיש לפריסה בשירותי Google Cloud כמו Cloud Run. פתרון האחסון הזה נקרא Artifact Registry, שירות מנוהל של Google Cloud שמיועד לאחסון פריטי מידע שנוצרו באפליקציה, כולל קובצי אימג' של קונטיינרים של Docker, חבילות Maven, מודולים של npm ועוד.

כדי ליצור מאגר ב-Google Cloud Artifact Registry, לוחצים על הכפתור המתאים.

e1123f0c924022e6.png

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

4e516ed209c470ee.png

חוזרים לסביבת הפיתוח המקומית, מתייגים את קובץ האימג' של הקונטיינר של האפליקציה ומעבירים אותו למאגר ב-Artifact Registry שיצרתם. כדי לעשות את זה, מריצים את הפקודות הבאות:

  • docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]
  • docker push TARGET_IMAGE[:TAG]

התוצאה אמורה להיראות כמו בצילום המסך הבא.

1e498feb4e88be9f.png

כל הכבוד 🎉🎉🎉 אפשר לעבור לשלב הבא. לפני כן, כדאי להקדיש 2 דקות כדי לנסות להעלות/להתחבר/להתנתק ולהכיר את נקודות הקצה של האפליקציה.תצטרכו אותן בהמשך.

הודעות שגיאה אפשריות

אם אתם מקבלים שגיאות שקשורות לקונטיינרים, אתם יכולים לנסות להשתמש ב-Gemini כדי להסביר ולתקן את השגיאה, ולספק:

  • קובץ ה-Dockerfile הנוכחי
  • השגיאה שהתקבלה
  • [אם צריך] קוד ה-PHP שמופעל.

הרשאות העלאה. אפשר גם לנסות את נקודת הקצה /upload.php ולנסות להעלות תמונה. יכול להיות שתופיע השגיאה הבאה. אם כן, צריך לתקן את chmod/chown בDockerfile.

Warning: move_uploaded_file(uploads/image (3).png): failed to open stream: Permission denied in /var/www/html/upload.php on line 11

PDOException "could not find driver" (או "Errore di connessione: could not find driver"). כדי להתחבר למסד הנתונים, ודאו שבקובץ ה-Dockerfile יש את ספריות ה-PDO המתאימות ל-mysql (pdo_mysql). כאן אפשר לקבל השראה מפתרונות.

לא ניתן להעביר את הבקשה לקצה העורפי. לא הצלחנו להתחבר לשרת ביציאה 8080. זה אומר שכנראה חשפתם את היציאה הלא נכונה. חשוב לוודא שאתם חושפים את היציאה שדרכה Apache/Nginx באמת פועלים. זה לא פשוט. אם אפשר, כדאי להגדיר את היציאה 8080 (זה מקל על העבודה עם Cloud Run). אם אתם רוצים להמשיך להשתמש ביציאה 80 (למשל, כי Apache דורש זאת), השתמשו בפקודה אחרת כדי להפעיל אותה:

$ docker run -it -p 8080:80 # force 80

# Use the PORT environment variable in Apache configuration files.

# https://cloud.google.com/run/docs/reference/container-contract#port

RUN sed -i 's/80/${PORT}/g' /etc/apache2/sites-available/000-default.conf /etc/apache2/ports.conf

5. מודול 3: פריסת האפליקציה ב-Cloud Run

9ffca42774f6c5d1.png

למה Cloud Run?

שאלה טובה. לפני כמה שנים, בטוח הייתם בוחרים ב-Google App Engine.

במילים פשוטות, ל-Cloud Run יש היום סטאק תוכנות חדש יותר, קל יותר לפרוס אותו, הוא זול יותר ואפשר לצמצם אותו אנכית בהתאם לעומס (scale down) ל-0 כשלא משתמשים בו. הוא מאפשר להריץ כל קונטיינר ללא שמירת מצב (stateless) ומשתלב עם שירותים שונים של Google Cloud, ולכן הוא אידיאלי לפריסת מיקרו-שירותים ואפליקציות מודרניות עם תקורה מינימלית ויעילות מקסימלית.

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

דרישות מוקדמות

כדי לבצע את המשימה הזו, צריך להתקין את gcloud במחשב המקומי. אם לא, אפשר לעיין בהוראות כאן. אם אתם משתמשים ב-Google Cloud Shell, אתם לא צריכים לעשות כלום.

לפני הפריסה...

אם אתם עובדים בסביבה המקומית, בצעו אימות ב-Google Cloud באמצעות הפקודה הבאה:

  • $ gcloud auth login –update-adc # not needed in Cloud Shell

הפעולה הזו אמורה לאמת אתכם באמצעות התחברות ל-OAuth בדפדפן. חשוב לוודא שאתם מתחברים דרך Chrome עם אותו משתמש (למשל, vattelapesca@gmail.com) שמחובר ל-Google Cloud עם חיוב מופעל.

מפעילים את Cloud Run API באמצעות הפקודה הבאה:

  • $ gcloud services enable run.googleapis.com cloudbuild.googleapis.com

בשלב הזה הכול מוכן לפריסה ב-Cloud Run.

פריסת האפליקציה ב-Cloud Run באמצעות gcloud

הפקודה שמאפשרת לפרוס את האפליקציה ב-Cloud Run היא gcloud run deploy. יש כמה אפשרויות להגדרת היעד. אלה האפשרויות המינימליות (שאפשר לספק דרך שורת הפקודה, או שהכלי יבקש מכם באמצעות הנחיה אינטראקטיבית):

  1. השם של שירות Cloud Run שרוצים לפרוס באפליקציה. שירות Cloud Run יחזיר כתובת URL שמספקת נקודת קצה לאפליקציה.
  2. האזור ב-Google Cloud שבו האפליקציה תפעל. (--region REGION)
  3. קובץ אימג' של קונטיינר שעוטף את האפליקציה.
  4. משתני סביבה שהאפליקציה צריכה להשתמש בהם במהלך ההפעלה שלה.
  5. הדגל Allow-Unauthenticated שמאפשר לכולם לגשת לאפליקציה בלי אימות נוסף.

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

הפריסה תימשך כמה דקות. אם הכל תקין, אמור להופיע משהו כזה במסוף Google Cloud.

ef1029fb62f8de81.pngf7191d579c21ca3e.png

לוחצים על כתובת ה-URL שסופקה על ידי Cloud Run ובודקים את האפליקציה. אחרי האימות, אמור להופיע משהו כזה.

d571a90cd5a373f9.png

"gcloud run deploy" ללא ארגומנטים

יכול להיות ששמתם לב ש-gcloud run deploy שואל אתכם את השאלות הנכונות ומשלים את הפרטים שחסרים. איזה יופי!

עם זאת, בכמה מודולים נוסיף את הפקודה הזו לטריגר לפיתוח גרסת Build של Cloud Build, כך שלא נוכל להשתמש בשאלות אינטראקטיביות. אנחנו צריכים למלא את כל האפשרויות בפקודה. אז אתם רוצים ליצור את gcloud run deploy --option1 blah --foo bar --region your-fav-region הזהב. איך עושים את זה?

  1. חוזרים על שלבים 2-3-4 עד ש-gcloud מפסיק לשאול שאלות:
  2. [LOOP] gcloud run deploy עם אפשרויות שנמצאו עד עכשיו
  3. ‫[LOOP] מערכות מבקשות את אפשרות X
  4. [LOOP] Search in public docs how to set up X from CLI adding option --my-option [my-value].
  5. עכשיו חוזרים לשלב 2, אלא אם gcloud מסתיים בלי שאלות נוספות.
  6. הפריסה של gcloud run deploy בלה בלה בלה פשוט מעולה! שומרים את הפקודה במקום כלשהו, כי תצטרכו אותה בהמשך בשלב של Cloud Build.

כאן אפשר למצוא פתרון אפשרי. המסמכים זמינים כאן.

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

6. Module 4: Clean Password with Secret Manager

95cd57b03b4e3c73.png

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

איטרציה ראשונה: מעדכנים את config.php כדי להשתמש ב-ENV

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

<?php
// Database configuration with ENV variables. Set default values as well 
$db_host = getenv('DB_HOST') ?: 'localhost';
$db_name = getenv('DB_NAME') ?: 'image_catalog';
$db_user = getenv('DB_USER') ?: 'appmod-phpapp-user';
$db_pass = getenv('DB_PASS') ?: 'wrong_password';
// Note getenv() is PHP 5.3 compatible
try {
    $pdo = new PDO("mysql:host=$db_host;dbname=$db_name", $db_user, $db_pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    die("Errore di connessione: " . $e->getMessage());
}

session_start();
?>

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

  • בזמן ה-build, בקובץ Docker. מוסיפים לקובץ ה-Dockerfile הקודם את 4 הפרמטרים באמצעות התחביר ENV DB_VAR=ENV_VAR_VALUE. הפעולה הזו תגדיר ערכי ברירת מחדל שאפשר לשנות בזמן הריצה. לדוגמה, אפשר להגדיר כאן את "DB_NAME" ו-"DB_USER" ולא בשום מקום אחר.
  • בזמן ההרצה. אתם יכולים להגדיר את המשתנים האלה ל-Cloud Run, גם מ-CLI וגם מממשק המשתמש. זה המקום הנכון להזין את כל 4 המשתנים (אלא אם אתם רוצים להשאיר את ברירות המחדל שהוגדרו בקובץ Docker).

ב-localhost, כדאי לשים את משתני ה-ENV בקובץ .env (אפשר לבדוק בתיקיית solutions).

חשוב גם לוודא שהקובץ ‎ .env נוסף ל-.gitignore : אתם לא רוצים לדחוף את הסודות שלכם ל-GitHub!

echo .env >> .gitignore

אחרי זה, אפשר לבדוק את המכונה באופן מקומי:

docker run -it -p 8080:8080 --env-file .env my-php-app-docker

עכשיו השגתם את הדברים הבאים:

  1. האפליקציה תקרא את המשתנה באופן דינמי מה-ENV
  2. שיפרתם את האבטחה כי הסרתם את הסיסמה למסד הנתונים מהקוד)

עכשיו אפשר לפרוס גרסה חדשה ב-Cloud Run. בואו נעבור לממשק המשתמש ונגדיר את משתני הסביבה באופן ידני:

  • נכנסים לכתובת https://console.cloud.google.com/run.
  • לוחצים על האפליקציה
  • לוחצים על "עריכה ופריסה של גרסה חדשה".
  • בכרטיסייה הראשונה "מאגרים", לוחצים על הכרטיסייה התחתונה "משתנים וסודות".
  • לוחצים על "+ הוספת משתנה" ומוסיפים את כל המשתנים הדרושים. התוצאה אמורה להיראות בערך כך:

7a5fbfa448544d3.pngf2780c35585388ca.png

האם זה מושלם? לא. רוב המפעילים עדיין יכולים לראות את ה-PASS שלכם. אפשר לצמצם את האיום באמצעות Google Cloud Secret Manager.

איטרציה שנייה: Secret Manager

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

הסיסמאות עדיין גלויות לכל מי שיש לו גישה למסוף Google Cloud. למעשה, אם תיכנסו לקובץ הפריסה של Cloud Run YAML, תוכלו לאחזר אותו. לחלופין, אם תנסו לערוך או לפרוס גרסה חדשה של Cloud Run, הסיסמה תופיע בקטע Variables & Secrets, כמו שמוצג בצילומי המסך הבאים.

‫Secret Manager של Google Cloud הוא שירות מאובטח ומרכזי לניהול מידע רגיש כמו מפתחות API, סיסמאות, אישורים וסודות אחרים.

הוא מאפשר לאחסן סודות, לנהל אותם ולגשת אליהם באמצעות הרשאות פרטניות והצפנה חזקה. הכלי Secret Manager משולב עם ניהול זהויות והרשאות גישה (IAM) ב-Google Cloud, ומאפשר לכם לקבוע למי תהיה גישה לסודות ספציפיים, כדי להבטיח את אבטחת המידע והעמידה בתקנות.

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

כדי לגשת ל-Secret Manager, בתפריט האפשרויות הנוספות עוברים לשירותי Security ומוצאים אותו בקטע Data Protection, כמו שמוצג בצילום המסך הבא.

6df83a1c3cb757f6.png

מפעילים את Secret Manager API, כמו שמוצג בתמונה הבאה.

a96c312e2c098db1.png

  • עכשיו לוחצים על Create a secret (יצירת סוד): נקרא לו באופן הגיוני:
  • שם: php-amarcord-db-pass
  • ערך הסוד: "הסיסמה של מסד הנתונים" (התעלמו מהחלק "העלאת קובץ").
  • הוסיפו הערה לקישור הסודי הזה, הוא אמור להיראות כמו projects/123456789012/secrets/php-amarcord-db-pass. זהו המצביע הייחודי לסוד שלכם (ל-Terraform, ל-Cloud Run ולאחרים). המספר הוא מספר הפרויקט הייחודי שלכם.

טיפ: נסו להשתמש במוסכמות עקביות למתן שמות לסודות, משמאל לימין, לדוגמה: cloud-devrel-phpamarcord-dbpass

  • ארגון (עם החברה)
  • צוות (בתוך הארגון)
  • בקשה (בתוך הצוות)
  • שם המשתנה (בתוך האפליקציה)

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

יצירת גרסה חדשה של Cloud Run

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

  • גישה ל-Cloud Run באמצעות מסוף Google Cloud
  • בוחרים את האפליקציה.
  • לוחצים על "Edit & Deploy a New Revision" (עריכה ופריסה של גרסה חדשה).
  • מאתרים את הכרטיסייה "משתנים וסודות".
  • משתמשים בכפתור "+ Reference a Secret" כדי לאפס את משתנה הסביבה DB_PASS.
  • צריך להשתמש באותו "DB_PASS" עבור הסודות שאליהם מפנים, ולהשתמש בגרסה העדכנית.

9ed4e35be7654dcb.png

בסיום, אמורה להופיע השגיאה הבאה:

da0ccd7af39b04ed.png

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

אחרי שתבינו מה הבעיה, חזרו ל-Cloud Run ופרסו מחדש גרסה חדשה. התוצאה אמורה להיראות כמו בתמונה הבאה:

e89f9ca780169b6b.png

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

7. מודול 5: הגדרת CI/CD באמצעות Cloud Build

ba49b033c11be94c.png

למה צריך צינור עיבוד נתונים של CI/CD?

עד עכשיו, בטח כבר הקלדתם את gcloud run deploy כמה פעמים, אולי כדי לענות על אותה שאלה שוב ושוב.

נמאס לכם לפרוס את האפליקציה באופן ידני באמצעות gcloud run deploy? לא היה נחמד אם האפליקציה הייתה יכולה לפרוס את עצמה באופן אוטומטי בכל פעם שאתם מעבירים שינוי חדש למאגר Git?

כדי להשתמש בצינור עיבוד נתונים של CI/CD, צריך שני דברים:

  1. מאגר Git אישי: למזלכם, כבר הייתם אמורים ליצור עותק של מאגר הסדנה בחשבון GitHub שלכם בשלב 2. אם לא, צריך לחזור ולהשלים את השלב הזה. המאגר המפוצל אמור להיראות כך: https://github.com/<YOUR_GITHUB_USER>/app-mod-workshop
  2. Cloud Build. השירות המדהים והזול הזה מאפשר להגדיר אוטומציות של גרסאות build כמעט לכל דבר: Terraform, אפליקציות Docker, ועוד.

בקטע הזה נתמקד בהגדרה של Cloud Build.

הכירו את Cloud Build

נשתמש ב-Cloud Build כדי לבצע את הפעולות הבאות:

  • לבנות את המקור (באמצעות קובץ Docker). אפשר לחשוב על זה כעל "קובץ ZIP גדול" שמכיל את כל מה שצריך כדי ליצור ולהריץ אותו ("פריט ה-build").
  • להעביר את פריט המידע הזה בדחיפה ל-Artifact Registry‏ (AR).
  • ואז פורסים מ-AR ל-Cloud Run את האפליקציה php-amarcord.
  • הפעולה הזו תיצור גרסה חדשה ("גרסה") של האפליקציה הקיימת (כמו שכבה עם הקוד החדש) ואנחנו נגדיר אותה כך שתפנה את התנועה לגרסה החדשה אם ההעברה תצליח.

הנה דוגמה לכמה גרסאות build של האפליקציה שלי, php-amarcord:

f30f42d4571ad5e2.png

איך אנחנו עושים את כל זה?

  1. יוצרים קובץ YAML אחד מושלם: cloudbuild.yaml
  2. באמצעות יצירת טריגר לפיתוח גרסת Build של Cloud.
  3. באמצעות חיבור למאגר ב-GitHub דרך ממשק המשתמש של Cloud Build.

יצירת טריגר (וחיבור מאגר)

  • נכנסים לכתובת https://console.cloud.google.com/cloud-build/triggers.
  • לוחצים על "יצירת טריגר".
  • הידור:
  • שם: משהו משמעותי כמו on-git-commit-build-php-app
  • אירוע: Push to branch
  • מקור: "קישור מאגר חדש" טקסט חלופי
  • ייפתח חלון בצד שמאל: "קישור מאגר"
  • ספק המקור: "Github" (ראשון)
  • "Continue"
  • האימות יפתח חלון ב-GitHub לאימות צולב. צריך להתקדם בתהליך לפי רצף הפעולות ולהתאזר בסבלנות. אם יש לכם הרבה מאגרים, יכול להיות שזה ייקח קצת זמן.
  • בקטע "Select repo" (בחירת מאגר), בוחרים את החשבון או המאגר ומסמנים את התיבה "I understand...‎" (הבנתי…).
  • אם מופיעה השגיאה: אפליקציית GitHub לא מותקנת באף אחד מהמאגרים, לוחצים על Install Google Cloud Build ופועלים לפי ההוראות.
  • 23e0e0f1219afea3.pngלוחצים על "חיבור".
  • bafd904ec07122d2.png
  • בינגו! המאגר מקושר עכשיו.
  • בחזרה לחלק של הטריגר…
  • הגדרה: זיהוי אוטומטי (*)
  • מתקדם: בוחרים את חשבון השירות "[PROJECT_NUMBER]- compute@developer.gserviceaccount.com"
  • ‫xxxxx הוא מזהה הפרויקט
  • חשבון השירות שמוגדר כברירת מחדל ב-Compute Engine מתאים לשימוש בסביבת מעבדה, אבל אל תשתמשו בו בסביבת ייצור. ‫(מידע נוסף)
  • משאירים את כל השאר כמו שהוא.
  • לוחצים על הכפתור "יצירה".

‫(*) זו הדרך הפשוטה ביותר, כי היא בודקת אם יש קובץ Docker או cloudbuild.yaml. עם זאת, cloudbuild.yaml נותן לכם את הכוח להחליט מה לעשות בכל שלב.

יש לי את הכוח!

עכשיו הטריגר לא יפעל, אלא אם תתנו לחשבון השירות של Cloud Build (מה זה חשבון שירות? כתובת האימייל של "רובוט" שפועל בשמכם לביצוע משימה – במקרה הזה, בניית דברים ב-Cloud!).

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

  • עוברים אל Cloud Build ואז אל Settings.
  • חשבון השירות "‎[PROJECT_NUMBER]- compute@developer.gserviceaccount.com"
  • מסמנים את התיבות הבאות:
  • Cloud Run
  • Secret Manager
  • חשבונות שירות
  • Cloud Build
  • מסמנים גם את האפשרות "הגדרה כחשבון השירות המועדף".

8715acca72286a46.png

איפה נמצא קובץ ה-YAML של Cloud Build?

מומלץ מאוד להקדיש קצת זמן ליצירת קובץ YAML משלכם ב-Cloud Build.

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

עכשיו אפשר להעביר שינוי ל-GitHub ולראות את החלק של Cloud Build בתהליך.

ההגדרה של Cloud Build יכולה להיות מסובכת. כדאי להתכונן לכך שיהיו כמה סבבים של:

  • בדיקת היומנים בכתובת https://console.cloud.google.com/cloud-build/builds;region=global
  • איתור השגיאה.
  • תיקון בקוד והפעלה מחדש של git commit או git push.
  • לפעמים השגיאה היא לא בקוד, אלא בהגדרה כלשהי. במקרה כזה, אפשר להנפיק גרסה חדשה דרך ממשק המשתמש (Cloud Build‏ > Triggers > Run).

97acd16980a144ab.png

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

3da8723e4ff80c0a.png

תוכל לעשות זאת בשתי דרכים:

  • דרך ממשק המשתמש – על ידי הגדרה מחדש של משתני ENV
  • באמצעות CLI, על ידי יצירת הסקריפט "המושלם" בשבילכם. אפשר למצוא דוגמה כאן: gcloud-run-deploy.sh. צריך לשנות כמה דברים, למשל את נקודת הקצה ומספר הפרויקט. אפשר למצוא את מספר הפרויקט בסקירה הכללית של Cloud.

איך מבצעים commit לקוד ב-GitHub?

הסדנה הזו לא כוללת הדרכה על הדרך הטובה ביותר לבצע git push ל-GitHub. עם זאת, אם נתקעתם ואתם ב-Cloud Shell, יש שתי דרכים:

  1. CLI. מוסיפים מפתח SSH באופן מקומי ומוסיפים מאגר מרוחק באמצעות git@github.com:YOUR_USER/app-mod-workshop.git (במקום http)
  2. VSCode. אם אתם משתמשים בכלי העריכה של Cloud Shell, אתם יכולים להשתמש בכרטיסייה Source control (‏ctrl-shift-G), ללחוץ על sync changes ולפעול לפי ההוראות. אמורה להיות לכם אפשרות לאמת את חשבון GitHub ב-VS Code, ואז תוכלו לבצע בקלות פעולות של משיכה ודחיפה.

f0d53f839c7fa3b6.png

חשוב לזכור git add clodubuild.yaml בין קבצים אחרים, אחרת זה לא יעבוד.

Deep vs Shallow "dev/prod parity" [optional]

אם העתקתם את גרסת המודל מכאן, יהיו לכם שתי גרסאות זהות של DEV ו-PROD. זה מגניב, ותואם לכלל 10 של The Twelve-Factor App.

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

אם יש לכם זמן להפיק גרסה "מעמיקה", חשוב לזכור את כל המשאבים שצריך לשכפל, כמו:

  • מסד נתונים של Cloud SQL (וכנראה גם מכונת SQL).
  • קטגוריית GCS
  • פונקציה של Cloud Functions.
  • אתם יכולים להשתמש ב-Gemini 1.5 Flash כמודל בפיתוח (זול ומהיר יותר) וב-Gemini 1.5 Pro (חזק יותר).

באופן כללי, בכל פעם שאתם עושים משהו שקשור לאפליקציה, חשבו באופן ביקורתי: האם לייצור צריך להיות אותו ערך או לא? אם לא, תצטרכו להשקיע מאמץ כפול. כמובן שהרבה יותר קל לעשות את זה באמצעות Terraform, שמאפשר להוסיף את הסביבה (‎-dev, -prod) כסיומת למשאבים.

8. מודול 6: מעבר ל-Google Cloud Storage

a680e0f287dd2dfb.png

אחסון

dc3a4b8ea92aaef6.png

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

איך פותרים את הבעיה? יש כמה גישות.

  1. שומרים את התמונות במסד הנתונים. זה מה שעשיתי בסופו של דבר עם אפליקציית ה-PHP הקודמת שלי. זה הפתרון הכי פשוט כי הוא לא מוסיף מורכבות. אבל זה בהחלט מוסיף זמן אחזור ועומס למסד הנתונים.
  2. להעביר את האפליקציה ב-Cloud Run לפתרון שמתאים לאחסון: GCE + Persistent disk? אולי GKE + Storage? הערה: ככל שרמת השליטה גבוהה יותר, כך רמת הגמישות נמוכה יותר.
  3. עוברים אל GCS. ‫Google Cloud Storage מציע את האחסון הטוב ביותר לכל Google Cloud, והוא הפתרון הכי מתאים לענן. עם זאת, צריך להשתמש בספריות PHP. האם יש לנו ספריות PHP 5.7 ל-GCS? האם PHP 5.7 בכלל תומך ב-Composer (נראה ש-PHP 5.3.2 היא הגרסה המוקדמת ביותר שנתמכת על ידי Composer)?
  4. אולי להשתמש בdocker sidecar?
  5. אפשר גם להשתמש ב-GCS Cloud Run Volume Mounts. זה נשמע מדהים.

🤔 העברת אחסון (שאלה פתוחה)

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

בדיקת קבלה

אני לא רוצה להגיד לך מה הפתרון, אבל אני רוצה שזה יקרה:

  1. אתם מעלים newpic.jpg. הוא מופיע באפליקציה.
  2. אתם משדרגים את האפליקציה לגרסה חדשה.
  3. ‫newpic.jpg עדיין שם, גלוי.

💡 פתרון אפשרי (GCS Cloud Run Volume Mounts)

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

כך תוכלו לטעון תיקייה מ-Cloud Run ל-GCS:

  1. כל ההעלאות ל-GCS יופיעו באפליקציה.
  2. כל ההעלאות לאפליקציה יועלו בפועל ל-GCS
  3. הקסם יקרה לאובייקטים שהועלו ב-GCS (פרק 7).

הערה. חשוב לקרוא את האותיות הקטנות של FUSE. זה לא בסדר אם יש בעיה בביצועים.

יצירת קטגוריה ב-GCS

‫GCS הוא שירות האחסון של Google Cloud שזמין בכל מקום. הוא נבדק בשטח ומשמש את כל שירותי GCP שזקוקים לאחסון.

שימו לב ש-Cloud Shell מייצא את PROJECT_ID בתור GOOGLE_CLOUD_PROJECT:

$ export PROJECT_ID=$GOOGLE_CLOUD_PROJECT

#!/bin/bash

set -euo pipefail

# Your Cloud Run Service Name, eg php-amarcord-dev
SERVICE_NAME='php-amarcord-dev'
BUCKET="${PROJECT_ID}-public-images"
GS_BUCKET="gs://${BUCKET}"

# Create bucket
gsutil mb -l "$GCP_REGION" -p "$PROJECT_ID" "$GS_BUCKET/"

# Copy original pictures there - better if you add an image of YOURS before.
gsutil cp ./uploads/*.png "$GS_BUCKET/"

הגדרת Cloud Run לטעינת הקטגוריה בתיקייה /uploads/‎

עכשיו הגענו לחלק האלגנטי. אנחנו יוצרים ווליום php_uploads ומורים ל-Cloud Run לבצע טעינת FUSE ב-MOUNT_PATH (משהו כמו /var/www/html/uploads/):

#!/bin/bash

set -euo pipefail

# .. keep variables from previous script..

# Uploads folder within your docker container.
# Tweak it for your app code.
MOUNT_PATH='/var/www/html/uploads/'

# Inject a volume mount to your GCS bucket in the right folder.
gcloud --project "$PROJECT_ID" beta run services update "$SERVICE_NAME" \
    --region $GCP_REGION \
    --execution-environment gen2 \
    --add-volume=name=php_uploads,type=cloud-storage,bucket="$BUCKET"  \
    --add-volume-mount=volume=php_uploads,mount-path="$MOUNT_PATH"

עכשיו חוזרים על השלב הזה לכל נקודות הקצה שרוצים להפנות ל-Cloud Storage.

אפשר גם לעשות את זה דרך ממשק המשתמש

  1. בכרטיסייה Volumes, יוצרים נקודות טעינה של אמצעי אחסון שמפנות לקטגוריה של Cloud Storage, מסוג קטגוריה של Cloud Storage, למשל בשם php_uploads.
  2. בקטע Container(s) > Volume Mounts, טוענים את אמצעי האחסון שיצרתם בנקודת אמצעי האחסון שנדרשת על ידי האפליקציה. זה תלוי בקובץ Docker, אבל יכול להיות שזה ייראה כמו var/www/html/uploads/ .

בכל מקרה, אם זה עובד, בעריכת הגרסה החדשה של Cloud Run אמור להופיע משהו כזה:

6c2bb98fc1b0e077.png

עכשיו בודקים את האפליקציה החדשה על ידי העלאת תמונה חדשה לנקודת הקצה (endpoint) של /upload.php.

התמונות אמורות לעבור בצורה חלקה ל-GCS בלי לכתוב שורת קוד אחת של PHP:

70032b216afee2d7.png

מה קרה?

משהו קסום קרה.

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

  • רוצים לשלוח אימייל בכל פעם שמתקבלת תמונה עם התוויות "מסוכן" או "עירום"? אפשר לעשות את זה בלי לגעת בקוד ה-PHP.
  • רוצים להשתמש במודל Gemini Multimodal כדי לתאר כל תמונה שמתקבלת, ולהעלות את התיאור למסד הנתונים? אפשר לעשות את זה בלי לגעת בקוד ה-PHP. אתם לא מאמינים לי? המשך הקריאה בפרק 7.

זה פותח לנו המון הזדמנויות.

9. מודול 7: שיפור האפליקציה באמצעות Google Gemini

c00425f0ad83b32c.png

עכשיו יש לכם אפליקציית PHP חדשה, מודרנית ונוצצת (כמו Fiat 126 משנת 2024) עם אחסון בענן.

מה אפשר לעשות איתה?

דרישות מוקדמות

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

בתרגיל הזה צריך:

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

הגדרת פונקציה של Cloud Functions (ב-Python)

תהיתם פעם איך מטמיעים אפליקציה מבוססת-אירועים? למשל:

  • כשמתרחש <אירוע> => נשלח אימייל
  • כשמתרחש <event> => אם <condition> נכון, מעדכנים את מסד הנתונים.

אירוע יכול להיות כל דבר, החל מרשומה חדשה שזמינה ב-BigQuery, אובייקט חדש שהשתנה בתיקייה ב-GCS או הודעה חדשה שממתינה בתור ב-Pub/Sub.

ב-Google Cloud יש כמה פרדיגמות שמאפשרות לעשות את זה. השינויים הבולטים ביותר:

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

שימו לב שהקוד לדוגמה מסופק בכפוף ל-.solutions/

הגדרת פונקציה של Cloud Functions (🐍 ‏python)

אנחנו מנסים ליצור GCF שאפתני מאוד.

  1. כשנוצרת תמונה חדשה ב-GCS.. (כנראה כי מישהו העלה אותו לאפליקציה – אבל לא רק)
  2. .. קוראים ל-Gemini כדי לתאר אותה ולקבל תיאור טקסטואלי של התמונה .. (כדאי לבדוק את ה-MIME ולוודא שמדובר בתמונה ולא בקובץ PDF,‏ MP3 או טקסט)
  3. .. and update the DB with this description. (יכול להיות שצריך לתקן את מסד הנתונים כדי להוסיף עמודה של description לטבלה images).

תיקון מסד הנתונים כדי להוסיף את description לתמונות

  1. פותחים את Cloud SQL Studio:

b92b07c4cba658ef.png

  1. מזינים את שם המשתמש והסיסמה למסד הנתונים של התמונות.
  2. מזריקים את קוד ה-SQL הזה, שמוסיף עמודה לתיאור תמונה:

ALTER TABLE images ADD COLUMN description TEXT;

3691aced78a6389.png

וזהו! כדי לבדוק אם זה עבד:

SELECT * FROM images;

עמודת התיאור החדשה אמורה להופיע:

bed69d6ad0263114.png

כותבים את f(x)‎ של Gemini.

הערה. הפונקציה הזו נוצרה בעזרת Gemini Code Assist.

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

  1. הפעלת ממשקי ה-API
  2. נכנסים לכתובת https://console.cloud.google.com/functions/list.
  3. לוחצים על "Create Function".
  4. הפעלת ממשקי API מאשף ה-API:

d22b82658cfd4c48.png

אפשר ליצור את ה-GCF מממשק המשתמש או משורת הפקודה. כאן נשתמש בשורת הפקודה.

אפשר למצוא קוד אפשרי בקטע .solutions/

  1. יוצרים תיקייה לאירוח הקוד, למשל "gcf/‎". נכנסים לתיקייה.
  2. יוצרים קובץ requirements.txt:
google-cloud-storage
google-cloud-aiplatform
pymysql
  1. יוצרים פונקציית Python. קוד לדוגמה: gcf/main.py.
#!/usr/bin/env python

"""Complete this"""

from google.cloud import storage
from google.cloud import aiplatform
import vertexai
from vertexai.generative_models import GenerativeModel, Part
import os
import pymysql
import pymysql.cursors

# Replace with your project ID
PROJECT_ID = "your-project-id"
GEMINI_MODEL = "gemini-1.5-pro-002"
DEFAULT_PROMPT = "Generate a caption for this image: "

def gemini_describe_image_from_gcs(gcs_url, image_prompt=DEFAULT_PROMPT):
    pass

def update_db_with_description(image_filename, caption, db_user, db_pass, db_host, db_name):
    pass

def generate_caption(event, context):
    """
    Cloud Function triggered by a GCS event.
    Args:
        event (dict): The dictionary with data specific to this type of event.
        context (google.cloud.functions.Context): The context parameter contains
                                                event metadata such as event ID
                                                and timestamp.
    """
    pass
  1. מפעילים את הפונקציה. אפשר להשתמש בסקריפט שדומה לזה: gcf/push-to-gcf.sh.

הערה 1. חשוב להגדיר את משתני הסביבה עם הערכים הנכונים, או פשוט להוסיף אותם למעלה (GS_BUCKET=blah, ..):

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

#!/bin/bash

set -euo pipefail

# add your logic here, for instance:
source .env || exit 2 

echo "Pushing ☁️ f(x)☁ to 🪣 $GS_BUCKET, along with DB config.. (DB_PASS=$DB_PASS)"

gcloud --project "$PROJECT_ID" functions deploy php_amarcord_generate_caption \
    --runtime python310 \
    --region "$GCP_REGION" \
    --trigger-event google.cloud.storage.object.v1.finalized \
    --trigger-resource "$BUCKET" \
    --set-env-vars "DB_HOST=$DB_HOST,DB_NAME=$DB_NAME,DB_PASS=$DB_PASS,DB_USER=$DB_USER" \
    --source . \
    --entry-point generate_caption \
    --gen2

הערה: בדוגמה הזו, generate_caption תהיה השיטה שמופעלת, והפונקציה של Cloud Functions תעביר אליה את האירוע של GCS עם כל המידע הרלוונטי (שם הקטגוריה, שם האובייקט וכו'). כדאי להקדיש קצת זמן לניפוי באגים של מילון ה-Python של האירוע הזה.

בדיקת הפונקציה

בדיקות יחידה (unit testing)

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

דוגמה לכך מופיעה בקובץ gcf/test.py.

ממשק המשתמש של Cloud Functions

כדאי גם להקדיש קצת זמן כדי לבחון את הפונקציה בממשק המשתמש. כדאי לבדוק כל כרטיסייה, במיוחד את Source (המועדפת עליי), Variables, Trigger ו-Logs. אתם תבלו הרבה זמן ב-Logs כדי לפתור שגיאות (אפשר גם לראות שגיאות אפשריות בתחתית הדף הזה). כדאי גם לבדוק את Permissions.

cf3ded30d532a2c7.png

בדיקת E2E

עכשיו אפשר לבדוק את הפונקציה באופן ידני.

  1. עוברים לאפליקציה ומתחברים.
  2. מעלים תמונה (לא גדולה מדי, כי נתקלנו בבעיות עם תמונות גדולות)
  3. בודקים בממשק המשתמש שהתמונה הועלתה.
  4. בודקים ב-Cloud SQL Studio שהתיאור עודכן. מתחברים ומריצים את השאילתה הזו: SELECT * FROM images.

43a680b12dbbdda0.png

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

עדכון PHP כדי להציג [אופציונלי]

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

אנחנו לא צריכים להיות מומחים ב-PHP כדי להוסיף את התיאור לקובץ index.php. הקוד הזה אמור לעשות את העבודה (כן, גם את הקוד הזה Gemini כתב בשבילי!):

<?php if (!empty($image['description'])): ?>
    <p class="font-bold">Gemini Caption:</p>
    <p class="italic"><?php echo $image['description']; ?></p>
<?php endif; ?>

ממקמים את הקוד הזה בתוך foreach לפי הטעם שלכם.

בשלבים הבאים נראה גם גרסה של ממשק משתמש יפה יותר, בזכות Gemini Code Assist. גרסה מעוצבת עשויה להיראות כך:

fdc12de0c88c4464.png

מסקנות

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

מה השלב הבא? אתם יכולים להשתמש באותו היגיון כדי להשיג שתי פונקציות נהדרות.

[optional] Add further Cloud Functions [open ended]

יש עוד כמה תכונות שיכולות לעזור.

📩 טריגר של אימייל

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

  • בתדירות גבוהה מדי? מוסיפים עוד אילוץ: תמונה גדולה, או תמונה שהתוכן שלה ב-Gemini מכיל את המילים "עירום/אלימות".
  • כדאי לבדוק את EventArc.

🚫 ניהול אוטומטי של תמונות לא הולמות

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

אזהרה. הפלט של ה-AI הגנרטיבי לא צפוי. לוודא ש"הפלט היצירתי" של Gemini מוגבל. אפשר לבקש תשובה דטרמיניסטית כמו ציון מהימנות מ-0 עד 1, קובץ JSON וכו'. יש הרבה דרכים לעשות את זה, למשל: * שימוש בספריות Python‏ pydantic,‏ langchain וכו'. * שימוש בפלט מובנה של Gemini.

טיפ. אפשר להשתמש בכמה פונקציות או בהנחיה אחת שמחייבת תשובה בפורמט JSON (עובד מצוין עם Gemini Structured Output, כמו שמוסבר למעלה), למשל:

איזו הנחיה צריך לתת כדי ליצור את זה?

{
    "description": "This is the picture of an arrosticino",
    "suitable": TRUE
}

אתם יכולים להוסיף להנחיה שדות נוספים כדי לקבל תובנות כמו: האם יש משהו טוב בזה? מה לא טוב? המקום מוכר לך? האם יש טקסט (OCR מעולם לא היה קל יותר):

  • goods: "זה נראה כמו אוכל טעים"
  • bads: "זה נראה כמו אוכל לא בריא"
  • ‫OCR: "Da consumare preferibilmente prima del 10 Novembre 2024"
  • location: "Pescara, Lungomare"

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

שגיאות אפשריות (בעיקר IAM או הרשאות)

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

שגיאה: אין מספיק הרשאות לחשבון השירות

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

22f51012fa6b4a24.png

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

שגיאה: חסר מפעיל של Cloud Run

  1. הערה נוספת לגבי ממשק המשתמש להרשאות של GCF (תפקיד Cloud Run Invoker):

be72e17294f2d3f3.png

כדי לתקן את השגיאה הזו, אפשר להריץ את הפקודה שבתמונה, שדומה ל-fix-permissions.sh

הבעיה הזו מתוארת כאן: https://cloud.google.com/functions/docs/securing/authenticating

שגיאה: חריגה ממגבלת הזיכרון

בפעם הראשונה שהרצתי אותו, ביומנים שלי היה כתוב: "חרגת ממגבלת הזיכרון של 244MiB, השתמשת ב-270MiB. כדאי להגדיל את מגבלת הזיכרון, כפי שמוסבר בכתובת https://cloud.google.com/functions/docs/configuring/memory'". שוב, מוסיפים זיכרון RAM ל-GCF. קל מאוד לעשות את זה בממשק המשתמש. הנה דוגמה לבעיה אפשרית:

bed69d6ad0263114.png

לחלופין, אפשר גם לתקן את סקריפט הפריסה של Cloud Run כדי להגדיל את הזיכרון או את המעבד (CPU). זה לוקח קצת יותר זמן.

שגיאה: PubSub פורסם

יצירת טריגר באמצעות GCF v1 גרמה פעם אחת לשגיאה הזו:

e5c338ee35ad4c24.png

גם את הבעיה הזו קל לפתור: נכנסים ל-IAM ונותנים לחשבון השירות את התפקיד "פרסום הודעות ב-Pub/Sub".

שגיאה: לא נעשה שימוש ב-Vertex AI

אם קיבלתם את הודעת השגיאה הזו:

Permission Denied: 403 Vertex AI API has not been used in project YOUR_PROJECT before or it is disabled.‎ כדי להפעיל אותו, נכנסים לכתובת https://console.developers.google.com/apis/api/aiplatform.googleapis.com/overview?project=YOR_PROJECT

אתם רק צריכים להפעיל את Vertex AI APIs. הדרך הקלה ביותר להפעיל את כל ממשקי ה-API הנדרשים היא:

  1. https://console.cloud.google.com/vertex-ai
  2. לוחצים על "הפעלת כל ממשקי ה-API המומלצים".

492f05ac377f3630.png

שגיאה: הטריגר של EventArc לא נמצא.

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

8ec4fc11833d7420.png

שגיאה: 400 סוכני שירות מוקצים

‫400 סוכני שירות מוקצים (https://cloud.google.com/vertex-ai/docs/general/access-control#service-agents). סוכני שירות נדרשים כדי לקרוא את קובץ Cloud Storage שסופק. כדאי לנסות שוב בעוד כמה דקות.

במקרה כזה, צריך לחכות קצת או לבקש עזרה מ-Googler.

10. מודול 8: יצירת יעדי SLO לזמינות

בפרק הזה ננסה להשיג את המטרה הבאה:

  1. יצירת מדדי SLI
  2. יצירת יעדי SLO על סמך מדדי ה-SLI
  3. יצירת התראות על סמך יעדי SLO

f63426182c052123.png

הנושא הזה קרוב מאוד לליבו של המחבר, כי ריקרדו עובד בתחום ה-SRE / DevOps ב-Google Cloud.

(שאלה פתוחה) יצירת SLIs ו-SLOs לאפליקציה הזו

מה שווה אפליקציה אם אי אפשר לדעת מתי היא לא פועלת?

מה זה SLO?

וואו! ‫Google המציאה את ה-SLO! כדי לקרוא עוד על הנושא, אפשר לעיין במקורות הבאים:

שלב 1: יצירת SLI או SLO לזמינות

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

למרבה המזל, Cloud Run מגיע עם תמיכה מובנית ב-SLO, בזכות Istio.

אחרי שהאפליקציה נמצאת ב-Cloud Run, קל מאוד לעשות את זה. לי זה לוקח 30 שניות.

  • נכנסים לדף Cloud Run.
  • לוחצים על האפליקציה או בוחרים אותה.
  • לוחצים על הכרטיסייה SLOs.
  • לוחצים על "‎+ Create SLO".
  • זמינות, מבוסס-בקשות
  • המשך
  • חודש קלנדרי / 99%.
  • לוחצים על Create SLO.

e471c7ebdc56cdf6.png

שלב 2: הגדרת התראות ל-SLO

אני ממליץ ליצור 2 התראות:

  1. אחד עם קצב ניצול נמוך ("Slowburn") כדי להתריע באימייל (מדמה כרטיס בעדיפות נמוכה).
  2. אחד עם קצב ניצול גבוה ("Fastburn") כדי להתריע באמצעות SMS (מדמה כרטיס בעדיפות גבוהה / זימונית)

עוברים אל SLO tab מהשלב הקודם.

חוזרים על הפעולה פעמיים:

314bfd6b9ef0a260.png

  • לוחצים על Create SLO Alert (הלחצן 🔔 עם סימן פלוס בפנים, בצד ימין).
  • משך תקופת המבט לאחור, סף קצב הניצול:
  • [FAST]. התקופה הראשונה: 60 דקות / 10 פעמים
  • [איטי]. שנייה: 720 דקות / 2 פעמים
  • ערוץ התראות: לוחצים על Manage notification channels.
  • קודם, "אימייל" -> הוספת חדש -> ..
  • שנית, "SMS" -> הוספת מספר חדש -> אימות בטלפון.
  • טיפ: אני אוהב להשתמש באמוג'י בשמות. זה כיף להדגמות.
  • כשמסיימים, לוחצים על ה-X הגדול בפינה השמאלית העליונה.
  • קודם בוחרים בטלפון (מהיר), ואז באימייל (איטי).
  • מוסיפים כמה מסמכים לדוגמה, כמו:
  • [PHP Amarcord] Riccardo told me to type sudo reboot or to check documentation in http://example.com/playbooks/1.php but I guess he was joking.

בינגו!

התוצאה הסופית

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

אם רוצים, אפשר להוסיף זמן אחזור (מומלץ מאוד לעשות זאת) או אפילו מדד מורכב יותר. בוחרים זמן אחזור שנראה לכם סביר. אם אתם לא בטוחים, בחרו באפשרות 200ms.

11. השלבים הבאים

השלמתם את כל המשימות, מה חסר?

כמה נקודות למחשבה:

מידע מועיל במשחק מ-Gemini

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

  1. Vertex AI. "הדרך הארגונית", שמשולבת ב-GCP, שאותה חקרנו בפרק 7 (GCF+Gemini). כל האימותים פועלים בצורה חלקה, והשירותים מקושרים זה לזה בצורה מושלמת.
  2. Google AI. "הדרך של הצרכן". אתם מקבלים מפתח Gemini API כאן ומתחילים ליצור סקריפטים קטנים שאפשר לקשר לכל עומס עבודה שכבר יש לכם (עבודה קניינית, עננים אחרים, מארח מקומי וכו'). אתם פשוט מחליפים את מפתח ה-API והקוד מתחיל לפעול באופן קסום.

אנחנו ממליצים לנסות את (2) בפרויקטים אישיים משלכם.

שיפור ממשק המשתמש

אני לא טוב בממשקי משתמש. אבל Gemini כן! אפשר פשוט לקחת דף PHP אחד ולומר משהו כזה:

I have a VERY old PHP application. I want to touch it as little as possible. Can you help me:

1. add some nice CSS to it, a single static include for tailwind or similar, whatever you prefer
2. Transform the image print with description into cards, which fit 4 per line in the canvas?

Here's the code:

-----------------------------------
[Paste your PHP page, for instance index.php - mind the token limit!]

אפשר לעשות את זה בקלות תוך פחות מ-5 דקות, באמצעות Cloud Build. :)

התשובה של Gemini הייתה מושלמת (כלומר, לא הייתי צריך לשנות כלום):

8a3d5fe37ec40bf8.png

וכך נראה הפריסה החדשה באפליקציה האישית של היוצר:

81620eb90ae3229a.png

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

אבטחה

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

אבל הנושא הזה חשוב מאוד. אספנו כמה רעיונות בSECURITY.

12. מעולה!

כל הכבוד 🎉🎉🎉 , הצלחתם לשדרג את אפליקציית ה-PHP הקודמת שלכם באמצעות Google Cloud.

24cb9a39b1841fbd.png

לסיכום, ב-Codelab הזה למדתם:

  • איך לפרוס מסד נתונים ב-Google Cloud SQL ואיך להעביר אליו את מסד הנתונים הקיים.
  • איך להכיל בקונטיינר את אפליקציית ה-PHP באמצעות Docker ו-Buildpacks, ולאחסן את קובץ האימג' שלה ב-Google Cloud Artifact Registry
  • איך פורסים אפליקציה בקונטיינר ב-Cloud Run ומפעילים אותה באמצעות Cloud SQL
  • איך לאחסן פרמטרים רגישים של הגדרות אישיות (כמו סיסמת מסד נתונים) או להשתמש בהם באופן סודי באמצעות Google Secret Manager
  • איך מגדירים את צינור עיבוד הנתונים של CI/CD באמצעות Google Cloud Build כדי לבנות ולפרוס באופן אוטומטי את אפליקציית ה-PHP בכל דחיפת קוד למאגר GitHub.
  • איך להשתמש ב-Cloud Storage כדי להעביר את משאבי האפליקציה לענן
  • איך להשתמש בטכנולוגיות ללא שרת (serverless) כדי ליצור תהליכי עבודה מדהימים ב-Google Cloud בלי לגעת בקוד של האפליקציה.
  • להשתמש ביכולות המולטי-מודאליות של Gemini בתרחיש שימוש מתאים.
  • הטמעת עקרונות SRE ב-Google Cloud

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

‫🔁 משוב

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

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

🙏 תודה

המחבר רוצה להודות ל-Mirko Gilioli ול-Maurizio Ipsale מ-Datatonic על העזרה בכתיבה ובבדיקת הפתרון.