התחברות מ-Google Kubernetes Engine ‏ (GKE) אל AlloyDB ל-PostgreSQL

כדי לקשר באופן מאובטח אפליקציה בקונטיינר באשכול של Google Kubernetes Engine Autopilot למכונה של AlloyDB ל-PostgreSQL, אתם יכולים לפרוס את AlloyDB Auth Proxy כקונטיינר משני (sidecar) דרך חיבור לרשת IP פרטית.

‫AlloyDB הוא שירות מנוהל של מסד נתונים שתואם ל-PostgreSQL ב- Google Cloud, ו-Google Kubernetes Engine עוזר לפרוס, לנהל ולהתאים לעומס (scale) באופן אוטומטי עומסי עבודה של Kubernetes.

מטרות

  • יוצרים קובץ אימג' של Docker ל-AlloyDB.
  • להריץ אפליקציה ב-Google Kubernetes Engine.
  • התחברות למכונה של AlloyDB באמצעות AlloyDB Auth Proxy וכתובת IP פנימית.

עלויות

המדריך הזה משתמש ברכיבים של Google Cloud, והשימוש בהם כרוך בתשלום, כולל:

  • AlloyDB
  • Google Kubernetes Engine
  • Artifact Registry

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

לפני שמתחילים

המסוף

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

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  5. Verify that billing is enabled for your Google Cloud project.

  6. מוודאים שיש את ההרשאות הנדרשות כדי להשלים את המדריך.

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

    הפעלת ממשקי ה-API

    1. בשלב Confirm project, לוחצים על Next כדי לאשר את שם הפרויקט שבו רוצים לבצע שינויים.

    2. בשלב Enable APIs, לוחצים על Enable כדי להפעיל את ממשקי ה-API הבאים:

      • AlloyDB API
      • Artifact Registry API
      • Compute Engine API
      • Cloud Resource Manager API
      • Cloud Build API
      • Container Registry API
      • Kubernetes Engine API
      • Service Networking API

gcloud

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

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  5. Verify that billing is enabled for your Google Cloud project.

  6. מוודאים שיש את ההרשאות הנדרשות כדי להשלים את המדריך.

במדריך הזה נשתמש באפליקציית האינטרנט לדוגמה לאיסוף הצבעות, שנקראת gke-alloydb-app.

התפקידים הנדרשים

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

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

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

הפעלת Cloud Shell

‫Cloud Shell היא סביבת מעטפת לניהול משאבים שמתארחים ב-Google Cloud.

ב-Cloud Shell מותקנים מראש כלי שורת הפקודה Google Cloud CLI ו-kubectl. ה-CLI של gcloud מספק את ממשק שורת הפקודה הראשי ל- Google Cloud. ‫kubectl מספק את ממשק שורת הפקודה הראשי להרצת פקודות באשכולות של Kubernetes.

המסוף

כדי להפעיל את Cloud Shell, מבצעים את השלבים הבאים:

  1. נכנסים למסוף Google Cloud .

    Google Cloud console

  2. לוחצים על הכפתור Activate Cloud Shell Activate Cloud Shell בחלק העליון של מסוף Google Cloud .

  3. בתיבת הדו-שיח Authorize Cloud Shell, לוחצים על Authorize.

    בחלק התחתון של המסוף ייפתח סשן של Cloud Shell בתוך מסגרת. אפשר להשתמש במעטפת הזו כדי להריץ פקודות של gcloud ו-kubectl.

    1. לפני שמריצים פקודות, מגדירים את פרויקט ברירת המחדל ב-Google Cloud CLI באמצעות הפקודה הבאה:

      gcloud config set project PROJECT_ID

      מחליפים את PROJECT_ID במזהה הפרויקט.

gcloud

  1. כדי להפעיל את Cloud Shell, מבצעים את השלבים הבאים:

  2. מפעילים את Cloud Shell במסוף Google Cloud .

    הפעלת Cloud Shell

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

  3. כדי לאתחל את הסביבה, מגדירים את פרויקט ברירת המחדל ב-Google Cloud CLI באמצעות הפקודה הבאה:

    gcloud config set project PROJECT_ID

    מחליפים את PROJECT_ID במזהה הפרויקט.

  4. מפעילים את ממשקי ה-API של Cloud שנדרשים כדי ליצור מכונות של AlloyDB ל-PostgreSQL ולהתחבר אליהן.

    gcloud services enable alloydb.googleapis.com \
    compute.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudbuild.googleapis.com \
    containerregistry.googleapis.com \
    servicenetworking.googleapis.com \
    artifactregistry.googleapis.com \
    container.googleapis.com

יצירת אשכול AlloyDB והמכונה הראשית שלו

אשכול AlloyDB מורכב מכמה צמתים בתוך ענן וירטואלי פרטי (VPC) של Google. כשיוצרים אשכול, מגדירים גם גישה לשירותים פרטיים בין אחד מה-VPC שלכם לבין ה-VPC שמנוהל על ידי Google ומכיל את האשכול החדש. כדי למנוע חשיפה של מסד הנתונים לאינטרנט הציבורי, מומלץ להשתמש בגישה לכתובת IP פנימית.

כדי להתחבר לאשכול AlloyDB ל-PostgreSQL מחוץ ל-VPC שהוגדר לו, צריך להגדיר גישה לשירות פרטי ב-VPC ל-AlloyDB ולהשתמש ברשת ברירת המחדל של ה-VPC כדי להריץ שאילתות מאפליקציה שנפרסה באשכול GKE.

המסוף

  1. נכנסים לדף Clusters.

    כניסה לדף Clusters

  2. בקטע Configure your cluster, בשדה Cluster ID מזינים מזהה לאשכול. הוא חייב להתחיל באות קטנה באנגלית ויכול לכלול אותיות קטנות, מספרים ומקפים, כמו alloydb-cluster.

  3. בשדה Password, מזינים את ה-CLUSTER_PASSWORD שבו רוצים להשתמש למשתמש ברירת המחדל של מסד הנתונים postgres בזמן יצירת האשכול.

  4. בשדה Database version, בוחרים את הגרסה הראשית של POSTGRES_VERSION לאשכול החדש ב-AlloyDB.

  5. בוחרים REGION לאשכול, למשל us-central1.

  6. בקטע Configure your primary instance:

    1. בשדה Instance ID, מזינים את INSTANCE_ID של המכונה הראשית, למשל alloydb-primary.

    2. בוחרים סדרת מכונות, למשל N2.

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

    4. כדי לוודא שטווח כתובות IP מוקצה לקישור בין רשתות שכנות (peering) של שירותים, מגדירים את החיבור לגישה לשירותים פרטיים (PSA):

      1. ברשימה Network, בוחרים באפשרות default.

      2. אם טווח כתובות IP כמו default-ip-range כבר שמור, בוחרים אותו מהרשימה Allocated IP range.

      3. אם לא הוקצה טווח כתובות IP, לוחצים על Allocate custom IP range כדי להקצות IP_RANGE_NAME פנימי חדש ולהגדיר את החיבור.

  7. לוחצים על Create cluster.

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

gcloud

  1. ב-Cloud Shell, בודקים אם טווח כתובות ה-IP (IPv4) שלא בשימוש כבר הוקצה להתאמת רשתות לשירות:

    gcloud services vpc-peerings list --network=default

    אם הפלט נראה כמו הפלט הבא, דלגו על השלב הבא:

    network: projects/493573376485/global/networks/default
peering: servicenetworking-googleapis-com
reservedPeeringRanges:
- default-ip-range
service: services/servicenetworking.googleapis.com

    בפלט הזה, הערך של reservedPeeringRanges הוא default-ip-range, ואפשר להשתמש בו בתור IP_RANGE_NAME כדי ליצור חיבור פרטי בשלב 3.

  2. ‫(אפשר לדלג על השלב הזה אם משתמשים בערך ברירת המחדל של reservedPeeringRanges) כדי להקצות כתובות IP שלא בשימוש ב-VPC, משתמשים בפקודה הבאה:

    gcloud compute addresses create IP_RANGE_NAME \
    --global \
    --purpose=VPC_PEERING \
    --prefix-length=16 \
    --description="VPC private service access" \
    --network=default

    מחליפים את IP_RANGE_NAME בשם של כתובות ה-IP הפנימיות הזמינות ברשת המשנה של AlloyDB, למשל alloydb-gke-psa-01.

  3. כדי להגדיר את הגישה לשירות באמצעות טווח כתובות ה-IP שהוקצה, מריצים את הפקודה הבאה:

    gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=IP_RANGE_NAME \
    --network=default

  4. כדי לפרוס את אשכול AlloyDB, מריצים את הפקודה הבאה:

    gcloud alloydb clusters create CLUSTER_ID \
    --database-version=POSTGRES_VERSION \
    --password=CLUSTER_PASSWORD \
    --network=default \
    --region=REGION \
    --project=PROJECT_ID

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫CLUSTER_ID: המזהה של האשכול שיוצרים. הוא חייב להתחיל באות קטנה באנגלית ויכול לכלול אותיות קטנות, מספרים ומקפים, למשל alloydb-cluster.

    • ‫VERSION: הגרסה הראשית של PostgreSQL שאתם רוצים ששרתי מסד הנתונים של האשכול יהיו תואמים לה. צריך לבחור אחת מהאפשרויות:

      • ‫14: לתאימות עם PostgreSQL 14

      • ‫15: לתאימות עם PostgreSQL 15

      • ‫16: לתאימות עם PostgreSQL 16

      • ‫17: לתאימות עם PostgreSQL 17, שהיא גרסת ברירת המחדל הנתמכת של PostgreSQL

      • ‫18, לתאימות עם PostgreSQL 18

    • ‫CLUSTER_PASSWORD: הסיסמה שבה משתמשים בשביל משתמש ברירת המחדל של postgres.

    • ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud שבו רוצים למקם את האשכול.

    • ‫REGION: שם האזור שבו נוצר אשכול AlloyDB, למשל us-central1.

  5. כדי לפרוס את המכונה הראשית של AlloyDB, מריצים את הפקודה הבאה:

    gcloud alloydb instances create INSTANCE_ID \
    --instance-type=PRIMARY \
    --cpu-count=NUM_CPU \
    --region=REGION \
    --cluster=CLUSTER_ID \
    --project=PROJECT_ID

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫INSTANCE_ID: שם המכונה של AlloyDB, למשל alloydb-primary.
    • ‫CLUSTER_ID בשם של אשכול AlloyDB, למשל alloydb-cluster.
    • ‫NUM_CPU במספר יחידות העיבוד הווירטואליות, למשל 2.
    • ‫PROJECT_ID במזהה הפרויקט ב- Google Cloud .
    • ‫REGION בשם האזור שבו נוצר אשכול AlloyDB, למשל us-central1.

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

התחברות למכונה הראשית ויצירת מסד נתונים ומשתמש ב-AlloyDB

כדי ליצור מסד נתונים ומשתמש במסד הנתונים במכונה הראשית, מבצעים את הפעולות הבאות:

המסוף

  1. אם אתם לא נמצאים בדף Overview של האשכול החדש שיצרתם, במסוף Google Cloud נכנסים לדף Clusters.

    כניסה לדף Clusters

  2. כדי להציג את הדף Overview של האשכול, לוחצים על שם האשכול CLUSTER_ID.

  3. בתפריט הניווט, לוחצים על AlloyDB Studio.

  4. בדף Sign in to AlloyDB Studio, מבצעים את הפעולות הבאות:

    1. ברשימה Database, בוחרים באפשרות postgres.

    2. ברשימה משתמש, בוחרים באפשרות postgres.

    3. בשדה Password, מזינים את הסיסמה CLUSTER_PASSWORD שיצרתם בשלב יצירת אשכול AlloyDB והמכונה הראשית שלו.

    4. לוחצים על אימות. בחלונית Explorer מוצגת רשימה של האובייקטים במסד הנתונים.

  5. בכרטיסייה עורך 1, מבצעים את הפעולות הבאות:

    1. יוצרים מסד נתונים של AlloyDB:

      CREATE DATABASE DATABASE_NAME;

      מחליפים את DATABASE_NAME בשם לבחירתכם, למשל tutorial_db.

    2. לוחצים על Run. מחכים עד שההודעה Statement executed successfully תופיע בחלונית Results.

    3. לוחצים על ניקוי.

    4. יוצרים משתמש וסיסמה למסד הנתונים של AlloyDB:

      CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';

      מחליפים את מה שכתוב בשדות הבאים:

      • ‫USERNAME: השם של משתמש AlloyDB, למשל tutorial_user.

      • ‫DATABASE_PASSWORD: הסיסמה למסד הנתונים ב-AlloyDB, למשל tutorial.

    5. לוחצים על Run. מחכים עד שההודעה Statement executed successfully תופיע בחלונית Results.

  6. בחלונית Explorer של AlloyDB Studio, לוחצים על Switch user/database.

  7. בדף Sign in to AlloyDB Studio, מבצעים את הפעולות הבאות:

    1. ברשימה Database, בוחרים את DATABASE_NAME, למשל tutorial_db.

    2. ברשימה משתמש, בוחרים באפשרות postgres.

    3. בשדה Password, מזינים את הסיסמה CLUSTER_PASSWORD שיצרתם בשלב יצירת אשכול AlloyDB והמכונה הראשית שלו.

    4. לוחצים על אימות. בחלונית Explorer מוצגת רשימה של האובייקטים במסד הנתונים.

  8. בכרטיסייה עורך 1, מבצעים את הפעולות הבאות:

    1. נותנים את כל ההרשאות למשתמש במסד הנתונים של AlloyDB:

      GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";

    2. לוחצים על Run. מחכים עד שההודעה Statement executed successfully תופיע בחלונית Results.

    3. לוחצים על ניקוי.

    4. נותנים הרשאות למשתמש במסד הנתונים של AlloyDB בסכימה הציבורית:

      GRANT CREATE ON SCHEMA public TO "USERNAME";

    5. לוחצים על Run. מחכים עד שההודעה Statement executed successfully תופיע בחלונית Results.

  9. שימו לב לשם של מסד הנתונים, לשם המשתמש ולסיסמה. המידע הזה משמש ליצירת סוד של Kubernetes.

gcloud

  1. כדי ליצור משתמש במסד הנתונים של AlloyDB, מריצים את הפקודה הבאה ב-Cloud Shell:

    gcloud alloydb users create USERNAME \
    --cluster=CLUSTER_ID \
    --region=REGION \
    --password=DATABASE_PASSWORD

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫USERNAME: השם של משתמש AlloyDB, למשל tutorial_user.
    • ‫CLUSTER_ID: המזהה של האשכול, למשל alloydb-cluster.
    • ‫REGION: האזור שבו נמצא האשכול, למשל us-central1.
    • ‫DATABASE_PASSWORD: הסיסמה למסד הנתונים ב-AlloyDB, למשל tutorial.

  2. כדי ליצור מסד נתונים ולהעניק הרשאות, צריך להתחבר לאשכול ולהריץ פקודות SQL. ב-Cloud Shell, משתמשים בלקוח psql כדי להתחבר למכונה.

  3. אחרי שמתחברים למכונה כמשתמש postgres, יוצרים את מסד הנתונים:

    CREATE DATABASE DATABASE_NAME;

    מחליפים את DATABASE_NAME בשם לבחירתכם, למשל tutorial_db.

  4. נותנים את כל ההרשאות למשתמש של מסד הנתונים ב-AlloyDB במסד הנתונים החדש:

    GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";

  5. מתחברים למסד הנתונים החדש ונותנים הרשאות לסכימה public:

    \c DATABASE_NAME
GRANT CREATE ON SCHEMA public TO "USERNAME";

  6. שימו לב לשם של מסד הנתונים, לשם המשתמש ולסיסמה. המידע הזה משמש ליצירת סוד של Kubernetes.

יצירת אשכול GKE Autopilot

אשכול מכיל לפחות מכונה אחת של מישור הבקרה של האשכול ומספר מכונות עובדות שנקראות צמתים. צמתים הם מכונות וירטואליות (VM) של Compute Engine שמריצות את תהליכי Kubernetes שנדרשים כדי להפוך אותן לחלק מהאשכול. פורסים אפליקציות באשכולות, והאפליקציות פועלות בצמתים.

המסוף

  1. נכנסים לדף Kubernetes Clusters במסוף Google Cloud .

    כניסה לדף Kubernetes Clusters

  2. לוחצים על יצירה.

  3. בשדה Name בדף Cluster Basics, מציינים את הערך GKE_CLUSTER_ID לאשכול Autopilot, למשל ap-cluster.

  4. בשדה Region, בוחרים את REGION, למשל us-central1.

  5. לוחצים על יצירה.

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

gcloud

יוצרים אשכול Autopilot:

gcloud container clusters create-auto GKE_CLUSTER_ID \
    --location=REGION

מחליפים את מה שכתוב בשדות הבאים:

  • ‫GKE_CLUSTER_ID: השם של אשכול Autopilot, למשל ap-cluster.
  • ‫REGION: שם האזור שבו נפרס אשכול GKE, למשל us-central1.

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

התחברות ל-AlloyDB באמצעות שרת ה-proxy לאימות של AlloyDB

מומלץ להשתמש ב-AlloyDB Auth Proxy כדי להתחבר ל-AlloyDB. שרת ה-proxy לאימות של AlloyDB מספק הצפנה ואימות חזקים באמצעות ניהול זהויות והרשאות גישה (IAM), שיכולים לעזור לשמור על אבטחת מסד הנתונים.

כשמתחברים באמצעות שרת ה-proxy לאימות של AlloyDB, הוא מתווסף ל-Pod באמצעות תבנית מאגר sidecar. הקונטיינר של AlloyDB Auth Proxy נמצא באותו Pod כמו האפליקציה, וכך האפליקציה יכולה להתחבר ל-AlloyDB Auth Proxy באמצעות localhost, מה שמשפר את האבטחה והביצועים.

איך נותנים ל-Artifact Registry גישה לחשבון השירות שמוגדר כברירת מחדל ב-Compute Engine

מקצים את התפקיד "קורא ב-Artifact Registry" (roles/artifactregistry.reader) לחשבון השירות שמוגדר כברירת מחדל ב-Compute Engine, כדי שהצמתים ב-Google Kubernetes Engine יוכלו לשלוף קובצי אימג' של קונטיינרים מ-Artifact Registry.

המסוף

  1. נכנסים לדף IAM במסוף Google Cloud .

    כניסה לדף IAM

  2. בדף Permissions for project "PROJECT_ID", מוצאים את השורה שמכילה את חשבון השירות שמוגדר כברירת המחדל של Compute,‏ PROJECT_NUMBER-compute@developer.gserviceaccount.com, ולוחצים על Edit principal בשורה הזו.

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

    1. נכנסים לדף Dashboard במסוף Google Cloud .

      כניסה לדף Dashboard

    2. לוחצים על הרשימה הנפתחת Select from בחלק העליון של הדף. בחלון Select from שמופיע, בוחרים את הפרויקט.

    הערך של PROJECT_NUMBER מופיע בכרטיס Project info במרכז הבקרה של הפרויקט.

  3. לוחצים על Add another role.

  4. כדי להקצות את התפקיד roles/artifactregistry.reader, לוחצים על בחירת תפקיד, בוחרים את Artifact Registry בקטע לפי מוצר או שירות ובוחרים את Artifact Registry Reader בקטע תפקידים.

  5. לוחצים על Save. החשבון הראשי יקבל את התפקיד.

gcloud

מקצים את התפקיד "קריאה ב-Artifact Registry" (roles/artifactregistry.reader) בפרויקט לחשבון השירות שמוגדר כברירת מחדל ב-Compute Engine:

PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com" \
    --role="roles/artifactregistry.reader" \
    --condition=None

מחליפים את PROJECT_ID במזהה הפרויקט.

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

מגדירים את Google Kubernetes Engine לאימות של שרת ה-Proxy לאימות של AlloyDB באמצעות איחוד זהויות של עומסי עבודה ל-GKE. באיחוד זהויות של עומסי עבודה ל-GKE, יוצרים חשבון שירות של Kubernetes לאפליקציה באשכול Google Kubernetes Engine, ומקצים תפקידי IAM לחשבון השירות הזה. יוצרים Kubernetes ServiceAccount ייחודי לכל אפליקציה, כדי שתוכלו להגביל את ההרשאות לכל אפליקציה בנפרד.

המסוף

  1. כדי להפעיל את Cloud Shell, מבצעים את השלבים הבאים:

  2. מפעילים את Cloud Shell במסוף Google Cloud .

    הפעלת Cloud Shell

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

  3. ב-Cloud Shell, מקבלים את פרטי הכניסה לאשכול:

    gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID

    הפקודה הזו מגדירה את kubectl כך שישתמש באשכול GKE שיצרתם.

  4. בעורך שבחרתם, מבצעים את הפעולות הבאות:

    1. פותחים את service-account.yaml באמצעות nano, לדוגמה:

      nano service-account.yaml

    2. מדביקים את התוכן הבא בעורך:

      apiVersion: v1
kind: ServiceAccount
metadata:
  name: KUBERNETES_SERVICEACCOUNT

      מחליפים את KUBERNETES_SERVICEACCOUNT בשם של Kubernetes ServiceAccount, למשל alloydb-sa.

    3. מקישים על Control+O, לוחצים על ENTER כדי לשמור את השינויים, ומקישים על Control+X כדי לצאת מהעורך.

  5. יוצרים ServiceAccount של Kubernetes לאפליקציה לדוגמה:

    kubectl apply -f service-account.yaml

  6. כדי להקצות תפקידי IAM ל-Kubernetes ServiceAccount, מבצעים את השלבים הבאים במסוף Google Cloud :

    1. נכנסים לדף IAM במסוף Google Cloud .

      כניסה לדף IAM

    2. בוחרים את הפרויקט הרצוי.

    3. לוחצים על הענקת גישה.

    4. בשדה New principals, מזינים את הפרטים הבאים:

      principal://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/PROJECT_ID.svc.id.goog/subject/ns/default/sa/KUBERNETES_SERVICEACCOUNT

      מחליפים את מה שכתוב בשדות הבאים:

      • ‫PROJECT_NUMBER: מספר הפרויקט.
      • PROJECT_ID: מזהה הפרויקט.
      • ‫KUBERNETES_SERVICEACCOUNT: השם של חשבון השירות ב-Kubernetes, למשל alloydb-sa.

    5. כדי להקצות את התפקיד roles/alloydb.client, ברשימה Select a role בוחרים באפשרות AlloyDB ל-PostgreSQL ואז באפשרות AlloyDB Client.

    6. לוחצים על Add another role.

    7. כדי להקצות את התפקיד roles/serviceusage.serviceUsageConsumer, ברשימה Select a role בוחרים באפשרות Service Usage ואז באפשרות Service Usage Consumer.

    8. לוחצים על Save.

gcloud

  1. במסוף Google Cloud , פותחים את Cloud Shell.

    פתיחת Cloud Shell

  2. ב-Cloud Shell, מקבלים את פרטי הכניסה לאשכול:

    gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID

    הפקודה הזו מגדירה את kubectl כך שישתמש באשכול GKE שיצרתם.

  3. בעורך שבחרתם, מבצעים את הפעולות הבאות:

    1. פותחים את service-account.yaml באמצעות nano, לדוגמה:

      nano service-account.yaml

    2. מדביקים את התוכן הבא בעורך:

      apiVersion: v1
kind: ServiceAccount
metadata:
  name: KUBERNETES_SERVICEACCOUNT

      מחליפים את KUBERNETES_SERVICEACCOUNT בשם של Kubernetes ServiceAccount, למשל alloydb-sa.

    3. מקישים על Control+O, לוחצים על ENTER כדי לשמור את השינויים, ומקישים על Control+X כדי לצאת מהעורך.

  4. יוצרים ServiceAccount של Kubernetes לאפליקציה לדוגמה:

    kubectl apply -f service-account.yaml

  5. מקצים את התפקידים "לקוח AlloyDB"‏ (roles/alloydb.client) ו"צרכן של שימוש בשירות" (roles/serviceusage.serviceUsageConsumer) בפרויקט ל-Kubernetes ServiceAccount:

    PROJECT_ID="PROJECT_ID"
KUBERNETES_SERVICEACCOUNT="KUBERNETES_SERVICEACCOUNT"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/$KUBERNETES_SERVICEACCOUNT" \
    --role="roles/alloydb.client" \
    --condition=None
gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/$KUBERNETES_SERVICEACCOUNT" \
    --role="roles/serviceusage.serviceUsageConsumer" \
    --condition=None

    מחליפים את מה שכתוב בשדות הבאים:

    • PROJECT_ID: מזהה הפרויקט.
    • ‫KUBERNETES_SERVICEACCOUNT: השם של חשבון השירות ב-Kubernetes, למשל alloydb-sa.

אכלוס Artifact Registry בתמונה של האפליקציה לדוגמה

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

המסוף

  1. נכנסים לדף Artifact Registry במסוף Google Cloud .

    כניסה ל-Artifact Registry

  2. כדי ליצור מאגר, לוחצים על .

  3. בשדה Name, מזינים את הערך REPOSITORY_ID, למשל gke-alloydb-sample-app.

  4. בקטע Format, בוחרים באפשרות Docker.

  5. בקטע Location type, בוחרים באפשרות Region ואז בוחרים את REGION, למשל us-central1.

  6. לוחצים על יצירה.

  7. כדי ליצור את קובץ האימג' של האפליקציה לדוגמה, מפעילים את Cloud Shell ומבצעים את השלבים הבאים:

  8. מפעילים את Cloud Shell במסוף Google Cloud .

    הפעלת Cloud Shell

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

    1. ב-Cloud Shell, משכפלים את המאגר עם קוד האפליקציה לדוגמה של gke-alloydb-app מ-GitHub:

        git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go

    2. בתיבת הדו-שיח Authorize Cloud Shell, לוחצים על Authorize. ההודעה הזו לא תופיע אם כבר ביצעתם את השלב הזה בעבר.

    3. כדי ליצור את מאגר Docker ולפרסם אותו ב-Artifact Registry, מריצים את הפקודה הבאה:

        gcloud builds submit --tag REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID

      מחליפים את מה שכתוב בשדות הבאים:

      • ‫PROJECT_ID: מזהה הפרויקט.
      • ‫REPOSITORY_ID: שם המאגר, למשל gke-alloydb-sample-app.
      • ‫SAMPLE_APPLICATION: השם של אפליקציית האינטרנט לדוגמה, למשל gke-alloydb-app.

gcloud

  1. ב-Cloud Shell, משתמשים בפקודה הבאה כדי לשכפל את המאגר עם קוד האפליקציה לדוגמה של gke-alloydb-app מ-GitHub:

     git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go

  2. יוצרים מאגר ב-Artifact Registry לקובצי אימג' של Docker:

    gcloud artifacts repositories create REPOSITORY_ID --location REGION --repository-format=docker --project PROJECT_ID

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫PROJECT_ID: מזהה הפרויקט.
    • ‫REPOSITORY_ID: שם המאגר, למשל gke-alloydb-sample-app.

  3. בתיבת הדו-שיח Authorize Cloud Shell, לוחצים על Authorize. ההודעה הזו לא תופיע אם כבר ביצעתם את השלב הזה בעבר.

  4. כדי ליצור קונטיינר של Docker ולפרסם אותו ב-Artifact Registry, משתמשים בפקודה הבאה:

     gcloud builds submit --tag  REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION --project PROJECT_ID

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫PROJECT_ID: מזהה הפרויקט.
    • ‫REPOSITORY_ID: שם המאגר, למשל gke-alloydb-sample-app.
    • ‫SAMPLE_APPLICATION: השם של אפליקציית האינטרנט לדוגמה, למשל gke-alloydb-app.

יצירת סוד ב-Kubernetes

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

המסוף

ב-Cloud Shell הפתוח, משתמשים ב-SECRET של Kubernetes, כמו gke-alloydb-secret, כדי לאחסן את פרטי החיבור:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

gcloud

משתמשים ב-SECRET של Kubernetes, כמו gke-alloydb-secret, כדי לאחסן את פרטי החיבור:

kubectl create secret generic SECRET \
  --from-literal=database=DATABASE_NAME \
  --from-literal=username=USERNAME \
  --from-literal=password=DATABASE_PASSWORD

פריסה והפעלה של שרת ה-proxy של AlloyDB בתבנית Sidecar

מומלץ להריץ את AlloyDB Proxy בתבנית sidecar כקונטיינר נוסף שמשתף Pod עם האפליקציה, מהסיבות הבאות:

  • מונעת חשיפה של תנועת ה-SQL באופן מקומי. ‫AlloyDB Proxy מספק הצפנה בחיבורים יוצאים, אבל צריך להגביל את החשיפה של חיבורים נכנסים.
  • מונעת נקודת כשל בודדת. הגישה של כל אפליקציה למסד הנתונים היא נפרדת, מה שהופך את המערכת לעמידה יותר.
  • מגביל את הגישה ל-AlloyDB Proxy, ומאפשר להשתמש בהרשאות IAM לכל אפליקציה במקום לחשוף את מסד הנתונים לכל האשכול.
  • מאפשרת להגדיר את היקף הבקשות למשאבים בצורה מדויקת יותר. מכיוון ש-AlloyDB Proxy צורך משאבים באופן ליניארי לשימוש, התבנית הזו מאפשרת לכם להגדיר את היקף המשאבים ולבקש אותם בצורה מדויקת יותר, כך שיתאימו לאפליקציות שלכם ככל שהן גדלות.
  • מאפשר להגדיר את האפליקציה כך שתתחבר באמצעות 127.0.0.1 ב-DB_PORT שציינתם בקטע של הפקודה.

אחרי שיוצרים אשכול GKE וקובץ אימג' של קונטיינר לאפליקציה, פורסים את האפליקציה בקונטיינר באשכול GKE.

המסוף

במדריך הזה תפרסו את אפליקציית האינטרנט לדוגמה לאיסוף הצבעות, gke-alloydb-app, שמשתמשת ב-AlloyDB בתור מאגר הנתונים.

  1. משיגים את ה-URI של החיבור (INSTANCE_URI) למכונה הראשית של AlloyDB:

    1. נכנסים לדף Clusters במסוף Google Cloud .

      כניסה לדף Clusters

    2. כדי להציג את הדף Overview של האשכול, לוחצים על שם האשכול בעמודה Resource name.

    3. בקטע Instances in your cluster, מאתרים את המכונה הראשית ועוברים לקטע Connectivity (או לוחצים על View connectivity configuration).

    4. בשדה Connection URI, לוחצים על הלחצן Copy to clipboard .

    מציינים את INSTANCE_URI בקובץ ההגדרה של proxy_sidecar_deployment.yaml בשלב 2.ב בקטע הזה.

  2. ב-Cloud Shell, מבצעים את הפעולות הבאות:

    1. פותחים את proxy_sidecar_deployment.yaml באמצעות כלי העריכה הרצוי, למשל nano:

      nano proxy_sidecar_deployment.yaml

    2. מדביקים את התוכן הבא בעורך:

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KUBERNETES_SERVICEACCOUNT
      containers:
      - name: SAMPLE_APPLICATION
        # Replace <PROJECT_ID> and <REGION> with your project ID and region.
        image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
        imagePullPolicy: Always
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: username
        - name: DB_PASS
          valueFrom:
           secretKeyRef:
              name: SECRET
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: database
      - name: alloydb-proxy
        # This uses the latest version of the AlloyDB Auth proxy
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        command:
          - "/alloydb-auth-proxy"
          #AlloyDB instance name as parameter for the AlloyDB proxy
          - "INSTANCE_URI"
        securityContext:
          runAsNonRoot: true
        resources:
          requests:
            memory: "2Gi"
            cpu:    "1"

      מחליפים את KUBERNETES_SERVICEACCOUNT בשם של Kubernetes ServiceAccount, ואת INSTANCE_URI בנתיב שהעתקתם בשלב 1.

    3. מקישים על Control+O, לוחצים על ENTER כדי לשמור את השינויים, ומקישים על Control+X כדי לצאת מהעורך.

  3. כדי לפרוס את האפליקציה gke-alloydb-app, צריך להחיל את קובץ ההגדרה:

    kubectl apply -f proxy_sidecar_deployment.yaml

  4. כדי לוודא שהאפליקציה פועלת, נכנסים לדף Workloads במסוף Google Cloud :

    כניסה לדף Workloads

    מוודאים שהסטטוס של הפריסה gke-alloydb הוא OK.

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

    1. פותחים את service.yaml:

      nano service.yaml

    2. מדביקים את התוכן הבא:

      apiVersion: v1
kind: Service
metadata:
  name: SAMPLE_APPLICATION
spec:
  type: LoadBalancer
  selector:
    app: SAMPLE_APPLICATION
  ports:
  - port: 80
    targetPort: 8080

      מחליפים את SAMPLE_APPLICATION בשם האפליקציה, למשל gke-alloydb-app.

    3. שומרים את השינויים ויוצאים מהעורך, ואז מפעילים את השירות:

      kubectl apply -f service.yaml

  6. כדי לקבל את כתובת ה-IP החיצונית של האפליקציה, נכנסים לדף Services & Ingress במסוף Google Cloud :

    כניסה לדף Services & Ingress

  7. משתמשים בערך שבעמודה External endpoints כדי לגשת לאפליקציה בכתובת ה-URL הבאה:

    http://EXTERNAL_IP

gcloud

במדריך הזה תפרסו את אפליקציית האינטרנט לדוגמה לאיסוף הצבעות, gke-alloydb-app, שמשתמשת ב-AlloyDB בתור מאגר הנתונים.

  1. משיגים את חיבור המכונה INSTANCE_URI של המכונה הראשית ב-AlloyDB שאליה רוצים לחבר את שרת ה-proxy של AlloyDB:

       gcloud alloydb instances describe INSTANCE_ID \
   --cluster=CLUSTER_ID \
   --region=REGION \
   --format="value(name)"

    מחליפים את מה שכתוב בשדות הבאים:

    • ‫INSTANCE_ID: שם המכונה, למשל alloydb-primary.
    • ‫CLUSTER_ID: שם האשכול, למשל alloydb-cluster.

    הפלט מכיל את הערך של INSTANCE_URI שציינתם בקובץ ההגדרה proxy_sidecar_deployment.yaml בשלב 2.ב בקטע הזה.

  2. בעורך לבחירתכם, למשל nano, מבצעים את הפעולות הבאות:

    1. פותחים את proxy_sidecar_deployment.yaml באמצעות כלי העריכה הרצוי, למשל nano:

      nano proxy_sidecar_deployment.yaml

    2. מדביקים את התוכן הבא בעורך:

      apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KUBERNETES_SERVICEACCOUNT
      containers:
      - name: SAMPLE_APPLICATION
        # Replace <PROJECT_ID> and <REGION> with your project ID and region.
        image: REGION-docker.pkg.dev/PROJECT_ID/REPOSITORY_ID/SAMPLE_APPLICATION:latest
        imagePullPolicy: Always
        # This app listens on port 8080 for web traffic by default.
        ports:
        - containerPort: 8080
        env:
        - name: PORT
          value: "8080"
        # This project uses environment variables to determine
        # how you would like to run your application
        # To use the Go connector (recommended) - use INSTANCE NAME
        # To use TCP - Setting INSTANCE_HOST will use TCP (e.g., 127.0.0.1)
        - name: INSTANCE_HOST
          value: "127.0.0.1"
        - name: DB_PORT
          value: "5432"
        # To use Automatic IAM Authentication (recommended)
        # use DB_IAM_USER instead of DB_USER
        # you may also remove the DB_PASS environment variable
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: username
        - name: DB_PASS
          valueFrom:
           secretKeyRef:
              name: SECRET
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: SECRET
              key: database
     # If you are using the Go connector (recommended), you can
      # remove alloydb-proxy (everything below this line)
      - name: alloydb-proxy
        # This uses the latest version of the AlloyDB Auth proxy
        # It is recommended to use a specific version for production environments.
        # See: https://github.com/GoogleCloudPlatform/alloydb-auth-proxy
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        command:
          - "/alloydb-auth-proxy"
          #AlloyDB instance name as parameter for the AlloyDB proxy
          # Use <INSTANCE_URI>
          - "INSTANCE_URI"
        securityContext:
          # The default AlloyDB Auth proxy image runs as the
          # "nonroot" user and group (uid: 65532) by default.
          runAsNonRoot: true
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

      מחליפים את KUBERNETES_SERVICEACCOUNT בשם של Kubernetes ServiceAccount, ואת INSTANCE_URI בנתיב למכונה הראשית של AlloyDB משלב 1, למשל projects/PROJECT_ID/locations/REGION/clusters/CLUSTER_ID/instances/INSTANCE_ID.

    3. מקישים על Control+O, לוחצים על ENTER כדי לשמור את השינויים, ומקישים על Control+X כדי לצאת מהעורך.

  3. כדי לפרוס את האפליקציה gke-alloydb-app, מחילים את קובץ ההגדרה proxy_sidecar_deployment.yaml שיצרתם בשלב הקודם:

    kubectl apply -f proxy_sidecar_deployment.yaml

  4. מוודאים שהסטטוס של שני הקונטיינרים ב-Pod הוא running:

    kubectl get pods

    פלט לדוגמה:

     NAME                          READY   STATUS    RESTARTS   AGE
 gke-alloydb-8d59bb4cc-62xgh   2/2     Running   0          2m53s

  5. כדי להתחבר לאפליקציית gke-alloydb-app לדוגמה, משתמשים בשירות – לדוגמה, מאזן עומסים חיצוני מסוג HTTP. בעורך שבחרתם, פועלים לפי השלבים הבאים:

    1. פותחים את service.yaml באמצעות nano, לדוגמה:

      nano service.yaml

    2. בעורך nano, מדביקים את התוכן הבא:

      apiVersion: v1
kind: Service
metadata:
  name: SAMPLE_APPLICATION
spec:
  type: LoadBalancer
  selector:
    app: SAMPLE_APPLICATION
  ports:
  - port: 80
    targetPort: 8080

      מחליפים את SAMPLE_APPLICATION בשם של אפליקציית האינטרנט לדוגמה, למשל gke-alloydb-app.

    3. מקישים על Control+O, לוחצים על ENTER כדי לשמור את השינויים, ומקישים על Control+X כדי לצאת מהעורך.

  6. כדי לפרוס את האפליקציה של השירות gke-alloydb-app, מחילים את הקובץ service.yaml:

     kubectl apply -f service.yaml

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

    kubectl get service

    פלט לדוגמה:

    NAME              TYPE           CLUSTER-IP       EXTERNAL-IP     PORT(S)        AGE
gke-alloydb-app   LoadBalancer   34.118.229.246   35.188.16.172   80:32712/TCP   45s
kubernetes        ClusterIP      34.118.224.1     <none>          443/TCP        85m

  8. משתמשים בערך של כתובת ה-IP החיצונית מהשלב הקודם כדי לגשת לאפליקציה לדוגמה בכתובת ה-URL הבאה:

    http://EXTERNAL-IP

קובצי תצורה לדוגמה

proxy_sidecar_deployment.yaml 

apiVersion: apps/v1
kind: Deployment
metadata:
  name: <YOUR-DEPLOYMENT-NAME>
spec:
  selector:
    matchLabels:
      app: <YOUR-APPLICATION-NAME>
  template:
    metadata:
      labels:
        app: <YOUR-APPLICATION-NAME>
    spec:
      serviceAccountName: <YOUR-KSA-NAME>
      containers:
      # Your application container goes here.
      - name: <YOUR-APPLICATION-NAME>
        image: <YOUR-APPLICATION-IMAGE-URL>
        env:
        - name: DB_HOST
          # The port value here (5432) should match the --port flag below.
          value: "localhost:5432"
        - name: DB_USER
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: username
        - name: DB_PASS
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: password
        - name: DB_NAME
          valueFrom:
            secretKeyRef:
              name: <YOUR-DB-SECRET>
              key: database
      # The Auth Proxy sidecar goes here.
      - name: alloydb-auth-proxy
        # Make sure you have automation that upgrades this version regularly.
        # A new version of the Proxy is released monthly with bug fixes,
        # security updates, and new features.
        image: gcr.io/alloydb-connectors/alloydb-auth-proxy:1.10.1
        args:
          # If you're connecting over public IP, enable this flag.
          # - "--public-ip"

          # If you're connecting with PSC, enable this flag:
          # - "--psc"

          # If you're using auto IAM authentication, enable this flag:
          # - "--auto-iam-authn"

          # Enable structured logging with Google's LogEntry format:
          - "--structured-logs"

          # Listen on localhost:5432 by default.
          - "--port=5432"
          # Specify your instance URI, e.g.,
          # "projects/myproject/locations/us-central1/clusters/mycluster/instances/myinstance"
          - "<INSTANCE-URI>"

        securityContext:
          # The default AlloyDB Auth Proxy image runs as the "nonroot" user and
          # group (uid: 65532) by default.
          runAsNonRoot: true
        # You should use resource requests/limits as a best practice to prevent
        # pods from consuming too many resources and affecting the execution of
        # other pods. You should adjust the following values based on what your
        # application needs. For details, see
        # https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
        resources:
          requests:
            # The proxy's memory use scales linearly with the number of active
            # connections. Fewer open connections will use less memory. Adjust
            # this value based on your application's requirements.
            memory: "2Gi"
            # The proxy's CPU use scales linearly with the amount of IO between
            # the database and the application. Adjust this value based on your
            # application's requirements.
            cpu:    "1"

service.yaml 

apiVersion: v1
kind: Service
metadata:
  name: <YOUR-SERVICE-NAME>
spec:
  type: LoadBalancer
  selector:
    app: <YOUR-APPLICATION-NAME>
  ports:
  - port: 80
    targetPort: 8080

service-account.yaml 

apiVersion: v1
kind: ServiceAccount
metadata:
  name: <YOUR-KSA-NAME> # TODO(developer): replace this value

הסרת המשאבים

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

מחיקת הפרויקט

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

כדי למחוק את הפרויקט:

  1. במסוף Google Cloud , נכנסים לדף Manage resources.

    ניהול משאבים

  2. ברשימת הפרויקטים, בוחרים את הפרויקט שרוצים למחוק ולוחצים על Delete.

  3. כדי למחוק את הפרויקט, כותבים את PROJECT_ID בתיבת הדו-שיח ולוחצים על Shut down.

המאמרים הבאים