Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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

במדריך הזה מוסבר איך להגדיר חיבור מאפליקציה שפועלת באשכול Google Kubernetes Engine Autopilot למכונת AlloyDB.

‫AlloyDB הוא שירות מנוהל של מסד נתונים שתואם ל-PostgreSQL ב- Google Cloud.

‫Google Kubernetes Engine עוזר לכם לפרוס, לשנות את גודל המשאבים ולנהל את Kubernetes באופן אוטומטי.

מטרות

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

עלויות

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

AlloyDB
Google Kubernetes Engine
Artifact Registry

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

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

המסוף

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

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

Verify that billing is enabled for your Google Cloud project.

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

Verify that billing is enabled for your Google Cloud project.

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

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

בשלב אישור הפרויקט, לוחצים על הבא כדי לאשר את שם הפרויקט שרוצים לבצע בו שינויים.
בשלב Enable APIs (הפעלת ממשקי API), לוחצים על 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

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

Verify that billing is enabled for your Google Cloud project.

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

Verify that billing is enabled for your Google Cloud project.

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

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

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

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

אדמין של מסדי נתונים (roles/iam.databasesAdmin)
אדמין של אשכול Kubernetes Engine (roles/container.clusterAdmin)
אדמין IAM בפרויקט (roles/resourcemanager.projectIamAdmin)
אדמין בחשבון שירות(roles/iam.serviceAccountAdmin)
אדמין ב-Kubernetes Engine‏(roles/container.admin)
אדמין של Artifact Registry(roles/artifactregistry.admin)

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

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

הפעלת Cloud Shell

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

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

המסוף

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

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

‫Google Cloud console
לוחצים על Activate Cloud Shell (הפעלת Cloud Shell) בחלק העליון של Google Cloud המסוף.
בתיבת הדו-שיח Authorize Cloud Shell (מתן הרשאה ל-Cloud Shell), לוחצים על Authorize (מתן הרשאה).

בחלק התחתון של המסוף ייפתח סשן של Cloud Shell בתוך מסגרת. משתמשים בשורת הפקודה הזו כדי להריץ את הפקודות gcloud ו-kubectl.
1. לפני שמריצים פקודות, מגדירים את פרויקט ברירת המחדל ב-Google Cloud CLI באמצעות הפקודה הבאה:
```
gcloud config set project PROJECT_ID
```
  מחליפים את PROJECT_ID במזהה הפרויקט.

gcloud

כדי להפעיל את Cloud Shell, מבצעים את השלבים הבאים.
במסוף Google Cloud , מפעילים את Cloud Shell.

הפעלת Cloud Shell

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

כדי לאתחל את הסביבה, מגדירים את פרויקט ברירת המחדל ב-Google Cloud CLI באמצעות הפקודה הבאה:
```
gcloud config set project PROJECT_ID
```
מחליפים את PROJECT_ID במזהה הפרויקט.

מפעילים את Cloud APIs שנדרשים כדי ליצור מכונת 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 שהוגדר לו, צריך להגדיר את ההגדרה של Private Service Access ב-VPC עבור AlloyDB ולהשתמש ברשת ה-VPC שמוגדרת כברירת מחדל כדי להריץ שאילתות מאפליקציה שנפרסה באשכול GKE.

המסוף

עוברים לדף Clusters.

מעבר אל Clusters
בקטע Configure your cluster (הגדרת האשכול), בשדה Cluster ID (מזהה האשכול), מזינים מזהה לאשכול. הוא חייב להתחיל באות קטנה באנגלית, ויכול לכלול אותיות קטנות, מספרים ומקפים, כמו alloydb-cluster.
בשדה Password (סיסמה), מזינים את הסיסמה של CLUSTER_PASSWORD שבה ישתמש משתמש מסד הנתונים של postgres כברירת מחדל בזמן יצירת האשכול.
בשדה Database version (גרסת מסד הנתונים), בוחרים את הגרסה הראשית POSTGRES_VERSION של אשכול AlloyDB החדש.
בוחרים REGION לאשכול, למשל us-central1.
בקטע Configure your primary instance (הגדרת המכונה הראשית), מבצעים את הפעולות הבאות:
1. בשדה Instance ID (מזהה המכונה), מזינים את INSTANCE_ID של המכונה הראשית, כמו alloydb-primary.
2. בוחרים סדרת מכונות, למשל N2.
3. בוחרים סוג מכונה ומציינים את מספר יחידות העיבוד הווירטואליות NUM_CPU, למשל 2.
4. כדי להבטיח שטווח כתובות IP יוקצה לקישור בין שירותים, צריך להגדיר את החיבור של הגישה לשירותים פרטיים (PSA):
  1. ברשימה Network בוחרים באפשרות default.
  2. אם טווח כתובות IP כמו default-ip-range כבר שמור, בוחרים אותו מהרשימה Allocated IP range.
  3. אם לא הוקצה טווח כתובות IP, לוחצים על הקצאת טווח כתובות IP בהתאמה אישית כדי להקצות IP_RANGE_NAME פנימי חדש ולהגדיר את החיבור.
לוחצים על יצירת אשכול.

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

gcloud

ב-Cloud Shell, בודקים אם טווח כתובות ה-IP (IPv4) שלא בשימוש כבר הוקצה ל-Service Peering:
```
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.
(אפשר לדלג על השלב הזה אם משתמשים בערך ברירת המחדל של 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.

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

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

כדי לפרוס את אשכול 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.
כדי לפרוס את המופע הראשי של 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

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

המסוף

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

מעבר אל Clusters
כדי להציג את הדף Overview (סקירה כללית) של האשכול, לוחצים על שם האשכול CLUSTER_ID.
בתפריט הניווט, לוחצים על AlloyDB Studio.
בדף Sign in to AlloyDB Studio, מבצעים את הפעולות הבאות:
1. ברשימה Database בוחרים באפשרות postgres.
2. ברשימה משתמש, בוחרים באפשרות postgres.
3. בשדה Password (סיסמה), מזינים את הסיסמה CLUSTER_PASSWORD שיצרתם במאמר יצירת אשכול AlloyDB והמופע הראשי שלו.
4. לוחצים על אימות. בחלונית Explorer מוצגת רשימה של האובייקטים במסד הנתונים.
בכרטיסייה Editor 1, מבצעים את הפעולות הבאות:
1. יצירת מסד נתונים של AlloyDB:
```
CREATE DATABASE DATABASE_NAME;
```
  מחליפים את DATABASE_NAME בשם לבחירתכם, למשל tutorial_db.
2. לוחצים על Run. מחכים שההודעה Statement executed successfully תוצג בחלונית תוצאות.
3. לוחצים על ניקוי.
4. יוצרים משתמש וסיסמה למסד נתונים של AlloyDB:
```
CREATE USER USERNAME WITH PASSWORD 'DATABASE_PASSWORD';
```
  מחליפים את מה שכתוב בשדות הבאים:
  - ‫USERNAME: השם של משתמש AlloyDB, למשל tutorial_user.
  - ‫DATABASE_PASSWORD: הסיסמה למסד הנתונים של AlloyDB, לדוגמה tutorial.
5. לוחצים על Run. מחכים שההודעה Statement executed successfully תוצג בחלונית תוצאות.
בחלונית Explorer של AlloyDB Studio, לוחצים על Switch user/database.
בדף Sign in to AlloyDB Studio, מבצעים את הפעולות הבאות:
1. ברשימה Database בוחרים באפשרות DATABASE_NAME, למשל tutorial_db.
2. ברשימה משתמש, בוחרים באפשרות postgres.
3. בשדה Password (סיסמה), מזינים את הסיסמה CLUSTER_PASSWORD שיצרתם במאמר יצירת אשכול AlloyDB והמופע הראשי שלו.
4. לוחצים על אימות. בחלונית Explorer מוצגת רשימה של האובייקטים במסד הנתונים.
בכרטיסייה Editor 1, מבצעים את הפעולות הבאות:
1. נותנים את כל ההרשאות למשתמש במסד הנתונים של AlloyDB:
```
GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";
```
2. לוחצים על Run. מחכים שההודעה Statement executed successfully תוצג בחלונית תוצאות.
3. לוחצים על ניקוי.
4. נותנים הרשאות למשתמש במסד הנתונים של AlloyDB בסכימה הציבורית:
```
GRANT CREATE ON SCHEMA public TO "USERNAME";
```
5. לוחצים על Run. מחכים שההודעה Statement executed successfully תוצג בחלונית תוצאות.
חשוב לרשום לפניכם את שם מסד הנתונים, שם המשתמש והסיסמה. משתמשים במידע הזה ביצירת סוד של Kubernetes.

gcloud

כדי ליצור משתמש במסד נתונים של 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.
כדי ליצור מסד נתונים ולהעניק הרשאות, צריך להתחבר לאשכול ולהריץ פקודות SQL. ב-Cloud Shell, משתמשים בלקוח psql כדי להתחבר למכונה.

הערה: כדי להתחבר למופע AlloyDB מ-Cloud Shell, צריך להשתמש בAlloyDB Auth Proxy. כדי להגדיר את הקישור בצורה פשוטה יותר, אפשר לבצע את השלבים האלה באמצעות AlloyDB Studio ב Google Cloud מסוף
.
אחרי שמתחברים למופע בתור משתמש postgres, יוצרים את מסד הנתונים:
```
CREATE DATABASE DATABASE_NAME;
```
מחליפים את DATABASE_NAME בשם לבחירתכם, למשל tutorial_db.
נותנים את כל ההרשאות למשתמש במסד הנתונים של AlloyDB במסד הנתונים החדש:
```
GRANT ALL PRIVILEGES ON DATABASE "DATABASE_NAME" to "USERNAME";
```
מתחברים למסד הנתונים החדש ומעניקים הרשאות בסכימה public:
```
\c DATABASE_NAME
GRANT CREATE ON SCHEMA public TO "USERNAME";
```
חשוב לרשום לפניכם את שם מסד הנתונים, שם המשתמש והסיסמה. משתמשים במידע הזה ביצירת סוד של Kubernetes.

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

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

המסוף

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

מעבר אל Kubernetes Clusters
לוחצים על יצירה.
מציינים GKE_CLUSTER_ID לאשכול Autopilot בשדה שם בדף פרטים בסיסיים על האשכול, למשל ap-cluster.
בשדה Region, בוחרים באפשרות REGION, כמו us-central1.
לוחצים על יצירה.

ממתינים ליצירת אשכול 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

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

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

יצירה והקצאה של תפקידים לחשבונות שירות של Google

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

כדי להריץ את AlloyDB Auth Proxy ב-Google Kubernetes Engine, צריך ליצור חשבון שירות של Google שייצג את האפליקציה. מומלץ ליצור חשבון שירות ייחודי לכל אפליקציה, במקום להשתמש באותו חשבון שירות בכל מקום. המודל הזה מאובטח יותר כי הוא מאפשר להגביל את ההרשאות לכל אפליקציה בנפרד.

המסוף

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

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

כדי לקבל את PROJECT_NUMBER, שהוא מזהה ייחודי שנוצר אוטומטית עבור הפרויקט שלכם, מבצעים את הפעולות הבאות:
1. נכנסים לדף Dashboard במסוף Google Cloud .
  
  כניסה ללוח הבקרה
2. לוחצים על הרשימה הנפתחת Select from בחלק העליון של הדף. בחלון בחירה מתוך שמופיע, בוחרים את הפרויקט.
המספר PROJECT_NUMBER מוצג בכרטיס Project info בלוח הבקרה של הפרויקט.
לוחצים על הוספת תפקיד נוסף.
כדי להעניק את התפקיד roles/artifactregistry.reader, לוחצים על בחירת תפקיד, בוחרים באפשרות Artifact Registry בקטע לפי מוצר או שירות, ואז בוחרים באפשרות Artifact Registry Reader בקטע תפקידים.
לוחצים על Save. החשבון הראשי מקבל את התפקיד.
כדי ליצור חשבון שירות לאפליקציית הדוגמה של GKE, עוברים לדף Service accounts. כניסה לדף Service accounts
בוחרים את הפרויקט הרצוי.
בדף חשבונות שירות עבור פרויקט "PROJECT_ID", לוחצים על יצירת חשבון שירות.
בקטע פרטי חשבון שירות בדף יצירת חשבון שירות, מזינים GSA_NAME בשדה שם חשבון שירות, למשל gke-alloydb-gsa.
לוחצים על Create and continue.

מופיע הקטע Grant this service account access to project (optional) בדף Create service account.
כדי להעניק את התפקיד roles/alloydb.client:
1. לוחצים על בחירת תפקיד.
2. בוחרים באפשרות Cloud AlloyDB מתוך לפי מוצר או שירות.
3. בוחרים באפשרות Cloud AlloyDB Client מתוך תפקידים.
לוחצים על הוספת תפקיד נוסף.
כדי להעניק את התפקיד roles/serviceusage.serviceUsageConsumer, לוחצים על בחירת תפקיד, בוחרים באפשרות Service Usage בקטע לפי מוצר או שירות, ואז בוחרים באפשרות Service Usage Consumer בקטע תפקידים.
לוחצים על סיום. לחשבון השירות של Google מוקצים תפקידים.

gcloud

כדי להעניק את ההרשאות הנדרשות לחשבון השירות שמוגדר כברירת מחדל ב-Google, כדי ש-Compute Engine יוכל לקרוא מ-Artifact Registry, מריצים את הפקודה הבאה:

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

כדי ליצור חשבון שירות של Google לאפליקציה, יוצרים חשבון שירות של IAM:
```
gcloud iam service-accounts create GSA_NAME \
--display-name="gke-tutorial-service-account"
```
מחליפים את GSA_NAME בשם של חשבון השירות החדש ב-IAM, כמו gke-alloydb-gsa.

כדי להעניק תפקידים של alloydb.client ו-serviceusage.serviceUsageConsumer ל-GSA של האפליקציה, משתמשים בפקודות הבאות:

gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/alloydb.client"
gcloud projects add-iam-policy-binding PROJECT_ID --member=serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com --role="roles/serviceusage.serviceUsageConsumer"

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

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

חשבון שירות של Google הוא זהות IAM שמייצגת את האפליקציה שלכם ב- Google Cloud. חשבון שירות של Kubernetes הוא זהות שמייצגת את האפליקציה שלכם באשכול Google Kubernetes Engine.

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

המסוף

כדי להפעיל את Cloud Shell, מבצעים את השלבים הבאים.
במסוף Google Cloud , מפעילים את Cloud Shell.

הפעלת Cloud Shell

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

ב-Cloud Shell, מקבלים את פרטי הכניסה של האשכול:
```
gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID
```
הפקודה הזו מגדירה את kubectl לשימוש באשכול GKE שיצרתם.
בעורך שבחרתם, מבצעים את הפעולות הבאות:
1. פותחים את service-account.yaml באמצעות nano, לדוגמה:
```
nano service-account.yaml
```
2. בעורך, מדביקים את התוכן הבא:
```
  apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: KSA_NAME
```
  מחליפים את KSA_NAME בשם של חשבון השירות, לדוגמה ksa-alloydb.
3. מקישים על Control+O, על ENTER כדי לשמור את השינויים ועל Control+X כדי לצאת מהעורך.
יוצרים חשבון שירות של Kubernetes עבור האפליקציה לדוגמה:
```
kubectl apply -f service-account.yaml
```
כדי לקשר את חשבון השירות של Kubernetes לחשבון השירות של Google, מבצעים את השלבים הבאים במסוף Google Cloud :
1. נכנסים לדף Service accounts במסוף Google Cloud .
  
  כניסה לדף Service accounts
2. בוחרים את הפרויקט הרצוי.
3. לוחצים על השם של חשבון השירות של Google GSA_NAME.
4. לוחצים על הכרטיסייה Permissions.
5. לוחצים על הענקת גישה.
6. בשדה New principals, מזינים את הערכים הבאים:
  
  serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]
7. ברשימה Select a role בוחרים באפשרות IAM > Workload Identity User.
8. לוחצים על Save.
ב-Cloud Shell, מוסיפים את ההערה iam.gke.io/gcp-service-account לחשבון השירות של Kubernetes, באמצעות כתובת האימייל של חשבון השירות של Google:
```
kubectl annotate serviceaccount \
  KSA_NAME \
  iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
```

gcloud

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

פתיחת Cloud Shell
ב-Cloud Shell, מקבלים את פרטי הכניסה של האשכול:
```
gcloud container clusters get-credentials GKE_CLUSTER_ID --region REGION --project PROJECT_ID
```
הפקודה הזו מגדירה את kubectl לשימוש באשכול GKE שיצרתם.
בעורך שבחרתם, מבצעים את הפעולות הבאות:
1. פותחים את service-account.yaml באמצעות nano, לדוגמה:
```
nano service-account.yaml
```
2. בעורך, מדביקים את התוכן הבא:
```
  apiVersion: v1
  kind: ServiceAccount
  metadata:
    name: KSA_NAME
```
  מחליפים את KSA_NAME בשם של חשבון השירות, לדוגמה ksa-alloydb.
3. מקישים על Control+O, על ENTER כדי לשמור את השינויים ועל Control+X כדי לצאת מהעורך.
יוצרים חשבון שירות של Kubernetes עבור האפליקציה לדוגמה:
```
kubectl apply -f service-account.yaml
```

כדי לתת לחשבון השירות של Kubernetes הרשאות להתחזות לחשבון השירות של Google, צריך ליצור קישור למדיניות IAM בין שני חשבונות השירות:

gcloud iam service-accounts add-iam-policy-binding \
   --role="roles/iam.workloadIdentityUser" \
   --member="serviceAccount:PROJECT_ID.svc.id.goog[default/KSA_NAME]" \
   GSA_NAME@PROJECT_ID.iam.gserviceaccount.com

מוסיפים את ההערה iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID לחשבון השירות ב-Kubernetes, באמצעות כתובת האימייל של חשבון השירות ב-Google:
```
kubectl annotate serviceaccount \
  KSA_NAME \
  iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
```

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

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

המסוף

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

כניסה ל-Artifact Registry
כדי ליצור מאגר, לוחצים על .
בשדה שם מזינים REPOSITORY_ID, למשל gke-alloydb-sample-app.
בקטע Format, בוחרים באפשרות Docker.
בקטע Location type, בוחרים באפשרות Region ובוחרים אזור כמו REGION, למשל us-central1.
לוחצים על יצירה.
כדי ליצור את תמונת האפליקציה לדוגמה, מפעילים את Cloud Shell ופועלים לפי השלבים הבאים.
במסוף Google Cloud , מפעילים את Cloud Shell.

הפעלת Cloud Shell

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

ב-Cloud Shell, משכפלים את המאגר עם קוד האפליקציה לדוגמה gke-alloydb-app מ-GitHub:
```
  git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go
```
בתיבת הדו-שיח Authorize Cloud Shell, לוחצים על Authorize. ההנחיה הזו לא מופיעה אם כבר ביצעתם את השלב הזה.
כדי ליצור את קובץ האימג' של 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

ב-Cloud Shell, משתמשים בפקודה הבאה כדי לשכפל את המאגר עם קוד האפליקציה לדוגמה gke-alloydb-app מ-GitHub:
```
 git clone https://github.com/GoogleCloudPlatform/alloydb-auth-proxy && cd alloydb-auth-proxy/examples/go
```
יוצרים מאגר ב-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.
בתיבת הדו-שיח Authorize Cloud Shell, לוחצים על Authorize. ההנחיה הזו לא מופיעה אם כבר ביצעתם את השלב הזה.
כדי ליצור קונטיינר 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 עבור מסד הנתונים, המשתמש והסיסמה של המשתמש, כדי שאפליקציית הדוגמה תוכל להשתמש בהם. הערכים של כל סוד מבוססים על הערכים שצוינו בשלב Connect to your primary instance and create an AlloyDB database and user במדריך הזה. מידע נוסף זמין במאמר בנושא Secrets.

המסוף

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

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

gcloud

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

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

פריסה והפעלה של AlloyDB Proxy בתבנית 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 כמאגר הנתונים.

מקבלים את חיבור המופע INSTANCE_URI למופע הראשי של AlloyDB:
1. נכנסים לדף Clusters במסוף Google Cloud .
  
  מעבר אל Clusters
2. כדי להציג את הדף Overview של האשכול, לוחצים על שם האשכול.
3. בטבלה Instances (מכונות), לוחצים על השם של המכונה הראשית.
4. בשדה Instance URI בדף Overview, לוחצים על Copy to clipboard.
מציינים את INSTANCE_URI בקובץ ההגדרה proxy_sidecar_deployment.yaml בשלב 2.ב בקטע הזה.

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

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

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KSA_NAME 
      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"

מחליפים את INSTANCE_URI בנתיב שהעתקתם בשלב 1.

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

כדי לפרוס את האפליקציה gke-alloydb-app, מחילים את קובץ ההגדרה:
```
kubectl apply -f proxy_sidecar_deployment.yaml
```
כדי לוודא שהאפליקציה פועלת, עוברים לדף Workloads במסוף Google Cloud :

כניסה לדף Workloads

בודקים שהסטטוס של הפריסה gke-alloydb הוא OK.
כדי להתחבר לאפליקציה לדוגמה באמצעות מאזן עומסים חיצוני, מבצעים את השלבים הבאים ב-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
```
כדי לקבל את כתובת ה-IP החיצונית של האפליקציה, עוברים לדף Services & Ingress במסוף Google Cloud :

כניסה אל Services & Ingress
משתמשים בערך שבעמודה External endpoints כדי לגשת לאפליקציה בכתובת ה-URL הבאה:

http://EXTERNAL_IP

gcloud

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

מקבלים את פרטי החיבור של המופע הראשי ב-AlloyDB שאליו רוצים לחבר את AlloyDB Proxy:‏ INSTANCE_URI
```
   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.ב בקטע הזה.

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

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

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gke-alloydb
spec:
  selector:
    matchLabels:
      app: SAMPLE_APPLICATION
  template:
    metadata:
      labels:
        app: SAMPLE_APPLICATION
    spec:
      serviceAccountName: KSA_NAME
      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"

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

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

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

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

kubectl get pods

פלט לדוגמה:

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

כדי להתחבר לאפליקציית 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 כדי לצאת מהעורך.
כדי לפרוס את אפליקציית השירות gke-alloydb-app, מחילים את הקובץ service.yaml:
```
 kubectl apply -f service.yaml
```

כדי לקבל את פרטי השירות, כולל כתובת ה-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

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

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

proxy_sidecar_deployment.yaml

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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:5342"
        - 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

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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

# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

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

הסרת המשאבים

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

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

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

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

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

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

התחברות מ-Google Kubernetes Engine ‏ (GKE) אל AlloyDB ל-PostgreSQL קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

מטרות

עלויות

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

המסוף

gcloud

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

הפעלת Cloud Shell

המסוף

gcloud

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

המסוף

gcloud

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

המסוף

gcloud

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

המסוף

gcloud

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

יצירה והקצאה של תפקידים לחשבונות שירות של Google

המסוף

gcloud

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

המסוף

gcloud

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

המסוף

gcloud

יצירת סוד ב-Kubernetes

המסוף

gcloud

פריסה והפעלה של AlloyDB Proxy בתבנית sidecar

המסוף

gcloud

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

proxy_sidecar_deployment.yaml

service.yaml

service-account.yaml

הסרת המשאבים

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

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

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