‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

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

כדי ליצור חיבורים מוצפנים ומורשים למכונות של AlloyDB ל-PostgreSQL, אתם יכולים להשתמש ב-AlloyDB Auth Proxy. מידע נוסף זמין במאמר מידע על שרת proxy לאימות של AlloyDB.

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

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

המארח של הלקוח צריך לעמוד בדרישות הבאות:

ללקוח צריך להיות נתיב רשת למכונה של AlloyDB, בהתאם לשיטת החיבור:
- גישה לשירותים פרטיים (ברירת המחדל): ללקוח צריכה להיות הרשאת גישה לרשת של הענן הווירטואלי הפרטי (VPC) שבה נמצאים המכונות. מארחי לקוח (כמו מכונות Compute Engine) ברשת ה-VPC הזו כוללים באופן טבעי את הרשת הזו. למארחים של לקוחות ברשתות חיצוניות (רשתות מקומיות או רשתות VPC שונות) יש את החשיפה הזו אם רשת ה-VPC של מכונת AlloyDB מחוברת לרשת החיצונית באמצעות מנהרת Cloud VPN או צירוף ל-VLAN של Dedicated Interconnect או של Partner Interconnect.
- ‫Private Service Connect: לרשת ה-VPC של הלקוח צריכה להיות נקודת קצה (endpoint) של Private Service Connect ורשומת DNS פרטית תואמת, וצריך להפעיל את לקוח Auth Proxy עם הדגל --psc.
- כתובת IP ציבורית: במכונה צריך להיות Public IP enabled, וצריך להפעיל את לקוח Auth Proxy עם הדגל --public-ip. כשמתחברים באמצעות שרת ה-proxy לאימות, לא צריך להוסיף את כתובת ה-IP של המארח של הלקוח לרשתות החיצוניות המורשות.
אם למארח הלקוח יש מדיניות חומת אש לתעבורה יוצאת, היא צריכה לאפשר חיבורים יוצאים ליציאה 5433 בכתובות ה-IP של המכונות של AlloyDB, ולאפשר חיבורים יוצאים ליציאה 443 (יציאת ה-HTTPS הרגילה) לכל כתובות ה-IP.
אם אתם משתמשים במכונה של Compute Engine כמארח הלקוח, צריך להיות לה היקף הגישה https://www.googleapis.com/auth/cloud-platform כדי שהיא תוכל להשתמש ב-AlloyDB API. אם צריך, משנים את היקף הגישה כך שיכלול את ההיקף הזה.

הורדת הלקוח של Auth Proxy

המכונה שאליה מורידים את לקוח Auth Proxy תלויה בשאלה אם רוצים להתחבר למכונות של AlloyDB מתוך רשת ה-VPC או מחוץ לה.

אם אתם רוצים להתחבר לאשכול באמצעות גישה לשירותים פרטיים, אתם יכולים להוריד את לקוח Auth Proxy למכונה וירטואלית (VM) של Compute Engine שפועלת ברשת ה-VPC שיש לה גישה לשירותים פרטיים לאשכול.

אם אתם מתכוונים להתחבר לאשכול מחוץ ל-VPC, המכונה שבה תתקינו אותו תלויה באסטרטגיית החיבור החיצוני שבה אתם משתמשים. לדוגמה, אתם יכולים להתקין את לקוח Auth Proxy במכונת macOS או Windows שנמצאת באופן מקומי באפליקציה, ואז להשתמש בשרת SOCKS שפועל ברשת ה-VPC של AlloyDB כמתווך בחיבור. מידע נוסף זמין במאמר התחברות לאשכול מחוץ ל-VPC שלו.

Linux

‫64 ביט (AMD)

מורידים את לקוח Auth Proxy:

wget https://storage.googleapis.com/alloydb-auth-proxy/v1.17.2/alloydb-auth-proxy.linux.amd64 -O alloydb-auth-proxy

הופכים את קובץ הלקוח של Auth Proxy לקובץ הפעלה:
```
chmod +x alloydb-auth-proxy
```
מוסיפים את לקוח Auth Proxy ל-PATH:
```
mkdir -p ~/.local/bin
mv alloydb-auth-proxy ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH"
```
כדי שהשינויים האלה יישמרו בין הסשנים, מוסיפים את export PATH="$HOME/.local/bin:$PATH" לקובץ ~/.bashrc או ~/.zshrc.

‫32 ביט (AMD)

מורידים את לקוח Auth Proxy:

wget https://storage.googleapis.com/alloydb-auth-proxy/v1.17.2/alloydb-auth-proxy.linux.386 -O alloydb-auth-proxy

הופכים את קובץ הלקוח של Auth Proxy לקובץ הפעלה:
```
chmod +x alloydb-auth-proxy
```
מוסיפים את לקוח Auth Proxy ל-PATH:
```
mkdir -p ~/.local/bin
mv alloydb-auth-proxy ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH"
```
כדי שהשינויים האלה יישמרו בין הסשנים, מוסיפים את export PATH="$HOME/.local/bin:$PATH" לקובץ ~/.bashrc או ~/.zshrc.

‫64 ביט (ARM)

מורידים את לקוח Auth Proxy:

wget https://storage.googleapis.com/alloydb-auth-proxy/v1.17.2/alloydb-auth-proxy.linux.arm64 -O alloydb-auth-proxy

הופכים את קובץ הלקוח של Auth Proxy לקובץ הפעלה:
```
chmod +x alloydb-auth-proxy
```
מוסיפים את לקוח Auth Proxy ל-PATH:
```
mkdir -p ~/.local/bin
mv alloydb-auth-proxy ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH"
```
כדי שהשינויים האלה יישמרו בין הסשנים, מוסיפים את export PATH="$HOME/.local/bin:$PATH" לקובץ ~/.bashrc או ~/.zshrc.

‫32 ביט (ARM)

מורידים את לקוח Auth Proxy:

wget https://storage.googleapis.com/alloydb-auth-proxy/v1.17.2/alloydb-auth-proxy.linux.arm -O alloydb-auth-proxy

הופכים את קובץ הלקוח של Auth Proxy לקובץ הפעלה:
```
chmod +x alloydb-auth-proxy
```
מוסיפים את לקוח Auth Proxy ל-PATH:
```
mkdir -p ~/.local/bin
mv alloydb-auth-proxy ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH"
```
כדי שהשינויים האלה יישמרו בין הסשנים, מוסיפים את export PATH="$HOME/.local/bin:$PATH" לקובץ ~/.bashrc או ~/.zshrc.

macOS

ARM64

מורידים את לקוח Auth Proxy:

curl -o alloydb-auth-proxy https://storage.googleapis.com/alloydb-auth-proxy/v1.17.2/alloydb-auth-proxy.darwin.arm64

הופכים את קובץ הלקוח של Auth Proxy לקובץ הפעלה:
```
chmod +x alloydb-auth-proxy
```
מוסיפים את לקוח Auth Proxy ל-PATH:
```
mkdir -p ~/.local/bin
mv alloydb-auth-proxy ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH"
```
כדי שהשינויים האלה יישמרו בין הסשנים, מוסיפים את export PATH="$HOME/.local/bin:$PATH" לקובץ ~/.bashrc או ~/.zshrc.

AMD64

מורידים את לקוח Auth Proxy:

curl -o alloydb-auth-proxy https://storage.googleapis.com/alloydb-auth-proxy/v1.17.2/alloydb-auth-proxy.darwin.amd64

הופכים את קובץ הלקוח של Auth Proxy לקובץ הפעלה:
```
chmod +x alloydb-auth-proxy
```
מוסיפים את לקוח Auth Proxy ל-PATH:
```
mkdir -p ~/.local/bin
mv alloydb-auth-proxy ~/.local/bin/
export PATH="$HOME/.local/bin:$PATH"
```
כדי שהשינויים האלה יישמרו בין הסשנים, מוסיפים את export PATH="$HOME/.local/bin:$PATH" לקובץ ~/.bashrc או ~/.zshrc.

Windows

64-ביט

לוחצים לחיצה ימנית על https://storage.googleapis.com/alloydb-auth-proxy/v1.17.2/alloydb-auth-proxy-x64.exe ובוחרים באפשרות Save Link As כדי להוריד את לקוח ה-Auth Proxy. משנים את שם הקובץ ל-alloydb-auth-proxy.exe.

מוסיפים את לקוח Auth Proxy ל-PATH:

New-Item -ItemType Directory -Force -Path "$HOME\bin"
Move-Item -Path .\alloydb-auth-proxy.exe -Destination "$HOME\bin"
$userPath = [Environment]::GetEnvironmentVariable("Path", "User")
[Environment]::SetEnvironmentVariable("Path", "$userPath;$HOME\bin", "User")

32 סיביות

לוחצים לחיצה ימנית על https://storage.googleapis.com/alloydb-auth-proxy/v1.17.2/alloydb-auth-proxy-x86.exe ובוחרים באפשרות Save Link As כדי להוריד את לקוח ה-Auth Proxy. משנים את שם הקובץ ל-alloydb-auth-proxy.exe.

מוסיפים את לקוח Auth Proxy ל-PATH:

New-Item -ItemType Directory -Force -Path "$HOME\bin"
Move-Item -Path .\alloydb-auth-proxy.exe -Destination "$HOME\bin"
$userPath = [Environment]::GetEnvironmentVariable("Path", "User")
[Environment]::SetEnvironmentVariable("Path", "$userPath;$HOME\bin", "User")

קובץ אימג' של Docker

כדי להקל עליכם, ב-Artifact Registry יש כמה קובצי אימג' של קונטיינרים שמכילים את לקוח ה-Auth Proxy.

אתם יכולים להעביר את קובץ האימג' האחרון למחשב המקומי באמצעות Docker, בעזרת הפקודה הבאה:

docker pull gcr.io/alloydb-connectors/alloydb-auth-proxy:latest

מערכת הפעלה אחרת

במערכות הפעלה אחרות שלא נכללות כאן, אפשר להדר את לקוח Auth Proxy מהמקור.

בחירת חשבון המשתמש בניהול זהויות והרשאות גישה (IAM) והכנה שלו לאימות

‫AlloyDB Auth Proxy תומך בשימוש בסוגים הבאים של חשבונות משתמשים ב-IAM כדי לאשר חיבורים בין הלקוח לבין מכונה של AlloyDB:

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

מומלץ להשתמש בחשבון שירות לצורך הרשאה בסביבות ייצור. חשבון שירות מקושר הוא האפשרות הכי מאובטחת, כי לא צריך להוריד מפתח.
חשבון המשתמש שלכם. אתם יכולים להשתמש בחשבון המשתמש שלכם ב-IAM כדי לאשר חיבורים.

השימוש בחשבון המשתמש שלכם נוח בסביבות פיתוח שבהן אתם מנהלים את המשאבים של AlloyDB באמצעות ה-CLI של gcloud, מפתחים את מסד הנתונים באמצעות כלי כמו psql ומפתחים קוד אפליקציה באותו מארח.
חשבון שירות שמנוהל על ידי משתמש. אתם יכולים ליצור חשבון שירות ב-IAM לאפליקציה, ואז לאשר חיבורים באמצעות חשבון השירות.

השתמשו בחשבון שירות בניהול המשתמש כשהמארח של הלקוח פועל מחוץ ל-Google Cloud ואי אפשר להשתמש בחשבון שירות מצורף.

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

הרשאות IAM נדרשות

לחשבון המשתמש ב-IAM שבו אתם משתמשים כדי לאשר חיבורים צריכות להיות ההרשאות שניתנות על ידי התפקידים המוגדרים מראש roles/alloydb.client (לקוח AlloyDB) ו-roles/serviceusage.serviceUsageConsumer (Service Usage Consumer).

כדי להקצות את התפקיד AlloyDB Client לחשבון משתמש ב-IAM:

צריך להפעיל את Cloud Resource Manager API בפרויקט ב- Google Cloud .
אתם צריכים את התפקיד הבסיסי roles/owner (בעלים) ב-IAM בפרויקט ב-Google Cloud , או תפקיד שכולל את ההרשאות הבאות:
- resourcemanager.projects.get
- resourcemanager.projects.getIamPolicy
- resourcemanager.projects.setIamPolicy
כדי לקבל את ההרשאות האלה בהתאם לעקרון של הרשאות מינימליות, בקשו מהאדמין להקצות לכם את התפקיד roles/resourcemanager.projectIamAdmin (אדמין IAM בפרויקט).

הפיכת פרטי הכניסה של IAM לזמינים במארח הלקוח

לקוח ה-Auth Proxy משתמש ב-Application Default Credentials ‏ (ADC) כדי לאתר את פרטי הכניסה של IAM במארח הלקוח. ברוב הסביבות פרטי הכניסה האלה כבר קיימים, כך שאין צורך להגדיר שום דבר. הלקוח של Auth Proxy מחפש את המקורות הבאים של פרטי הכניסה, לפי הסדר:

חשבון המשתמש שלכם. כשמפתחים באופן מקומי, מאמתים באמצעות חשבון המשתמש שלכם על ידי הפעלת הפקודה הבאה ב-CLI של gcloud:
```
gcloud auth application-default login
```
הלקוח של Auth Proxy מזהה את פרטי הכניסה האלה ומשתמש בהם. לא צריך להוריד מפתח לחשבון השירות.
חשבון שירות מצורף. כשהמארח של הלקוח פועל ב-Google Cloud(לדוגמה, במכונה של Compute Engine), שרת המטא-נתונים של הסביבה מספק את פרטי הכניסה מחשבון השירות המצורף. לקוח Auth Proxy מגלה את פרטי הכניסה האלה ומשתמש בהם בלי הגדרה נוספת.

מקורות אחרים של פרטי כניסה

השתמשו בשיטות הבאות רק כש-Application Default Credentials לא זמינים – לדוגמה, כשמריצים את לקוח Auth Proxy מחוץ ל-Google Cloud, או כשצריך לשנות את פרטי הכניסה בסביבה.

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

יוצרים מפתח לחשבון שירות בפורמט JSON ומורידים אותו למארח הלקוח. אחר כך מגדירים את משתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS לנתיב של קובץ המפתח:
```
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account-key.json"
```
אפשר גם לציין את הנתיב באמצעות הדגל --credentials-file כשמפעילים את לקוח Auth Proxy:
```
alloydb-auth-proxy --credentials-file /path/to/service-account-key.json INSTANCE_URI
```
שימו לב: אם לא מנהלים כראוי את המפתחות לחשבונות השירות הם עלולים לסכן את האבטחה. לפני שיוצרים מפתח, כדאי לשקול חלופה מאובטחת יותר.
טוקן גישה מסוג OAuth 2.0. השתמשו בטוקן גישה כשמערכת אחרת כבר מנפיקה בשבילכם טוקנים לטווח קצר – לדוגמה, צינור עיבוד נתונים של שילוב רציף (CI) שמקבל טוקן לפני שהוא מפעיל את לקוח Auth Proxy.

אם כבר יש לכם אסימון גישה תקף מסוג OAuth 2.0, אתם יכולים להעביר אותו ישירות כשאתם מפעילים את לקוח Auth Proxy:
```
alloydb-auth-proxy --token "ACCESS_TOKEN" INSTANCE_URI
```
פרטי הכניסה ל-CLI של gcloud. השתמשו בדגל --gcloud-auth רק כשאתם צריכים להשתמש שוב בסשן gcloud auth login קיים ואי אפשר להריץ את gcloud auth application-default login.

הדגל --gcloud-auth גורם ללקוח Auth Proxy להשתמש בחשבון שאימתתם באמצעות gcloud auth login, במקום להשתמש ב-Application Default Credentials. אנחנו לא ממליצים על הדגל הזה. במקום זאת, צריך להריץ את הפקודה gcloud auth application-default login.

איסוף של מזהי URI לחיבור למכונות AlloyDB

כשמפעילים את לקוח שרת ה-Proxy לאימות, מזהים את המכונה או המכונות של AlloyDB שאליהן רוצים להתחבר באמצעות הפורמט הבא של URI לחיבור:

projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID

כדי לראות רשימה של כל מזהי ה-URI של החיבורים של המכונות, משתמשים בפקודה alloydb instances list ב-CLI של gcloud:

gcloud alloydb instances list \
    --region=REGION_ID \
    --cluster=CLUSTER_ID \
    --project=PROJECT_ID

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

‫REGION_ID: האזור שבו נמצאות המכונות
‫CLUSTER_ID: המזהה של האשכול שבו נמצאים המופעים
‫PROJECT_ID: מזהה הפרויקט שבו נמצא האשכול

אוספים את ה-URI של החיבור לכל מכונה שאליה רוצים להתחבר.

הפעלת הלקוח של שרת ה-proxy לאימות

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

כשהוא מתחיל, לקוח Auth Proxy:

מאשר חיבורים למכונות AlloyDB באמצעות פרטי הכניסה והרשאות ה-IAM של חשבון המשתמש ב-IAM שהגדרתם. הוא מחפש פרטי כניסה לפי רצף ספציפי של שלבים.
מאשרת באופן אוטומטי חיבורים של כתובות IP ציבוריות לרשת המקור, אם במכונה מופעלת כתובת IP ציבורית.
מגדיר חיבור פרטי ב-mTLS 1.3 לשרת ה-Auth Proxy של כל מכונה.
מתחיל להאזין לבקשות חיבור של לקוחות מקומיים.

כברירת מחדל, לקוח ה-Auth Proxy מאזין לחיבורי TCP בכתובת ה-IP‏ 127.0.0.1, החל מיציאה 5432, ומוסיף מספר יציאה אחד לכל מכונה של AlloyDB מעבר למכונה הראשונה. כשמפעילים את לקוח Auth Proxy, אפשר לציין כתובת מאזין אחרת ויציאות אחרות.

שורת הפקודה

alloydb-auth-proxy INSTANCE_URI... \
    [ --credentials-file PATH_TO_KEY_FILE \ ]
    [ --token OAUTH_ACCESS_TOKEN \ ]
    [ --port INITIAL_PORT_NUMBER \ ]
    [ --address LOCAL_LISTENER_ADDRESS \ ]
    [ --auto-iam-authn \ ]
    [ --psc \ ]
    [ --public-ip \ ]
    [ --disable-built-in-telemetry ]

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

‫INSTANCE_URI: ה-URI של החיבור למכונה של AlloyDB שאליה רוצים להתחבר, בפורמט הבא:

projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID

כדי לשנות את יציאת המאזין המקומית שמוגדרת כברירת מחדל, שבה לקוח Auth Proxy ישתמש במכונה, מוסיפים ל-URI את פרמטר השאילתה port:

"projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID?port=PORT"
אופציונלי: PATH_TO_KEY_FILE: הנתיב לקובץ המפתח בפורמט JSON של חשבון השירות בניהול המשתמש, שמשמש לאישור החיבור.
‫OAUTH_ACCESS_TOKEN (אופציונלי): ערך של אסימון OAuth2 שמשמש לאישור החיבור.
‫INITIAL_PORT_NUMBER (אופציונלי): מספר היציאה ההתחלתי שבו צריך להשתמש במקום יציאת ברירת המחדל 5432 כשמאזינים לחיבורי TCP מקומיים.
אופציונלי: LOCAL_LISTENER_ADDRESS: כתובת המאזין שבה צריך להשתמש במקום ברירת המחדל 127.0.0.1 כשמאזינים לחיבורי TCP מקומיים.

הדגל האופציונלי --auto-iam-authn מאפשר לבצע אימות אוטומטי למכונה. הפעולה הזו פועלת רק למשתמש במסד הנתונים שמשויך לחשבון IAM שמריץ את לקוח Auth Proxy. מידע נוסף זמין במאמר אימות אוטומטי באמצעות שרת proxy לאימות.

הדגל האופציונלי --psc מאפשר ל-Auth Proxy להתחבר למכונה שבה מופעל Private Service Connect. מידע נוסף על הגדרת DNS באמצעות Private Service Connect זמין במאמר הגדרה של אזור מנוהל ב-DNS ורשומת DNS.

הדגל האופציונלי --public-ip מאפשר לשרת ה-proxy לאימות להתחבר למכונה שבה מופעלת כתובת IP ציבורית, באמצעות כתובת ה-IP הציבורית של המכונה. מידע נוסף על כתובת IP ציבורית זמין במאמר התחברות באמצעות כתובת IP ציבורית.

הדגל האופציונלי --disable-built-in-telemetry משבית את מדווח המדדים הפנימי שבו משתמש Auth Proxy כדי לדווח על תקינות החיבור והרשת. כברירת מחדל, שרת ה-proxy לאימות מדווח על הפעולות הפנימיות שלו לתחילית של מדד המערכת alloydb.googleapis.com. המדדים האלה עוזרים לשפר את הביצועים של AlloyDB ולזהות בעיות בקישוריות ללקוח. האפשרות הזו שימושית לאפליקציות שפועלות בסביבות שבהן ייצוא מדדים יוצאים מוגבל. כדי לבטל את ההסכמה לאיסוף נתוני הטלמטריה האלה, משתמשים בדגל הזה.

מאגר Docker

מפעילים את לקוח Auth Proxy באמצעות הפקודה docker run.

אם אתם משתמשים בפרטי הכניסה שסופקו על ידי המכונה של Compute Engine, אתם יכולים להשתמש בפקודה דומה לזו:

docker run \
  --publish 127.0.0.1:PORT:PORT \
  gcr.io/alloydb-connectors/alloydb-auth-proxy:latest \
  --address 0.0.0.0 \
  --port PORT \
  INSTANCE_URI

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

‫PORT: היציאה שמשמשת לחיבורים מקומיים ללקוח Auth Proxy. ערך ברירת המחדל הוא 5432.
‫INSTANCE_URI: ה-URI של החיבור למכונה של AlloyDB שאליה רוצים להתחבר, בפורמט הבא:

projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID

כדי לשנות את יציאת המאזין המקומית שמוגדרת כברירת מחדל, שבה משתמש לקוח Auth Proxy במכונה, מוסיפים ל-URI את הפרמטר port של השאילתה:

"projects/PROJECT_ID/locations/REGION_ID/clusters/CLUSTER_ID/instances/INSTANCE_ID?port=PORT"

תמיד צריך לציין את הקידומת 127.0.0.1 בדגל --publish כדי שלקוח Auth Proxy לא ייחשף מחוץ למארח המקומי.

הערך 0.0.0.0 בדגל --address נדרש כדי שהמאזין יהיה נגיש מחוץ לקונטיינר של Docker.

כדי לספק פרטי כניסה ששמרתם בקובץ JSON מקומי, צריך לכלול את הדגלים --volume ו---credentials-file כשמריצים את הפקודה docker run:

docker run \
  --volume PATH_TO_KEY_FILE:/key.json \
  --publish 127.0.0.1:PORT:PORT \
  gcr.io/alloydb-connectors/alloydb-auth-proxy:latest \
  --address 0.0.0.0 \
  --port PORT \
  --credentials-file=/key.json \
  INSTANCE_URI

מחליפים את PATH_TO_KEY_FILE בנתיב לקובץ המפתח בפורמט JSON של חשבון השירות בניהול המשתמש, שבו רוצים להשתמש כדי לאשר את החיבור.

דוגמאות לסטארט-אפים

בדוגמאות הבאות מוצגות דרכים שונות להפעלת לקוח Auth Proxy. הם משתמשים במזהי ה-URI האלה של חיבור למכונה לדוגמה:

projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary

projects/myproject/locations/us-central1/clusters/mycluster/instances/myreadpool

הפעלה בסיסית

alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary"

בדוגמה הזו, הלקוח של שרת ה-Proxy לאימות מאשר את החיבור לפי רצף שלבי האימות הרגיל שלו, ואז מתחיל להאזין לחיבורים מקומיים למכונה myprimary ב-127.0.0.1:5432.

הפעלה באמצעות חשבון שירות בניהול המשתמשים

alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary" \
  --credentials-file "myappaccount/key.json"

בדוגמה הזו, הלקוח של שרת ה-proxy לאימות מאשר את החיבור באמצעות מפתח ה-JSON של חשבון השירות בניהול המשתמש שמאוחסן ב-myappaccount/key.json, ואז מתחיל להאזין לחיבורים מקומיים למכונה myprimary ב-127.0.0.1:5432.

הפעלה של חיבור לכמה מופעים

alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary" \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myreadpool"

בדוגמה הזו, הלקוח של שרת ה-Proxy לאימות מאשר את החיבור לפי רצף שלבי האימות הרגיל שלו, ואז מתחיל להאזין לחיבורים מקומיים למכונה myprimary ב-127.0.0.1:5432 ולמכונה myreadpool ב-127.0.0.1:5433.

האזנה להפעלה ביציאות בהתאמה אישית

שימוש ביציאות בהתאמה אישית ללקוח Auth Proxy יכול להיות שימושי כשצריך לשמור את יציאה 5432 לחיבורים אחרים של PostgreSQL.

alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary?port=5000" \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myreadpool?port=5001"

בדוגמה הזו, הלקוח של שרת ה-Proxy לאימות מאשר את החיבור לפי רצף שלבי האימות הרגיל שלו, ואז מתחיל להאזין לחיבורים מקומיים למכונה myprimary ב-127.0.0.1:5000 ולמכונה myreadpool ב-127.0.0.1:5001.

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

alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary" \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myreadpool" \
  --port 5000

האזנה להפעלה בכתובת IP מותאמת אישית

alloydb-auth-proxy \
  "projects/myproject/locations/us-central1/clusters/mycluster/instances/myprimary" \
  --address "0.0.0.0"

בדוגמה הזו, הלקוח של שרת ה-Proxy לאימות מאשר את החיבור לפי רצף שלבי האימות הרגיל שלו, ואז מתחיל להאזין לחיבורים מקומיים למכונה myprimary ב-0.0.0.0:5432.

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

בדוגמאות הבאות מוסבר איך לחבר אפליקציה למסד נתונים באמצעות AlloyDB Auth Proxy.

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

בשפות תכנות מסוימות, החיבור למכונה של AlloyDB באמצעות Auth Proxy זהה לחיבור למכונה של Cloud SQL ל-PostgreSQL באמצעות Cloud SQL Auth Proxy, ולכן הדוגמאות לשפות זהות לאלה של Cloud SQL ל-PostgreSQL.

הדוגמאות האלה מבוססות על הפעלה של לקוח Auth Proxy כברירת מחדל, כך שהוא מאזין לחיבורי TCP מקומיים ב-127.0.0.1:5432.

psql

psql -h 127.0.0.1 -p 5432 -U DB_USER

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

תתבקשו להזין את הסיסמה של המשתמש DB_USER.

Python

import os

import sqlalchemy


# connect_tcp_socket initializes a TCP connection pool
# for an AlloyDB instance.
def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    # Note: Saving credentials in environment variables is convenient, but not
    # secure - consider a more secure solution such as
    # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
    # keep secrets safe.
    INSTANCE_HOST = os.environ[
        "INSTANCE_HOST"
    ]  # e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
    db_user = os.environ["DB_USER"]  # e.g. 'my-db-user'
    db_pass = os.environ["DB_PASS"]  # e.g. 'my-db-password'
    db_name = os.environ["DB_NAME"]  # e.g. 'my-database'
    db_port = os.environ["DB_PORT"]  # e.g. 5432

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # postgresql+pg8000://<db_user>:<db_pass>@<INSTANCE_HOST>:<db_port>/<db_name>
        sqlalchemy.engine.url.URL.create(
            drivername="postgresql+pg8000",
            username=db_user,
            password=db_pass,
            host=INSTANCE_HOST,
            port=db_port,
            database=db_name,
        ),
        # ...
    )
    return pool

Java


import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class TcpConnectionPoolFactory extends ConnectionPoolFactory {

  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  private static final String DB_USER = System.getenv("DB_USER");
  private static final String DB_PASS = System.getenv("DB_PASS");
  private static final String DB_NAME = System.getenv("DB_NAME");

  private static final String INSTANCE_HOST = System.getenv("INSTANCE_HOST");
  private static final String DB_PORT = System.getenv("DB_PORT");


  public static DataSource createConnectionPool() {
    // The configuration object specifies behaviors for the connection pool.
    HikariConfig config = new HikariConfig();

    // The following URL is equivalent to setting the config options below:
    // jdbc:postgresql://<INSTANCE_HOST>:<DB_PORT>/<DB_NAME>?user=<DB_USER>&password=<DB_PASS>l

    // Configure which instance and what database user to connect with.
    config.setJdbcUrl(String.format("jdbc:postgresql://%s:%s/%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "postgres"
    config.setPassword(DB_PASS); // e.g. "my-password"



    // ... Specify additional connection properties here.
    // ...

    // Initialize the connection pool using the configuration object.
    return new HikariDataSource(config);
  }
}

Node.js

const Knex = require('knex');
const fs = require('fs');

// createTcpPool initializes a TCP connection pool for an AlloyDB cluster.
const createTcpPool = async config => {
  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  const dbConfig = {
    client: 'pg',
    connection: {
      host: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
      port: process.env.DB_PORT, // e.g. '5432'
      user: process.env.DB_USER, // e.g. 'my-user'
      password: process.env.DB_PASS, // e.g. 'my-user-password'
      database: process.env.DB_NAME, // e.g. 'my-database'
    },
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return Knex(dbConfig);
};

המשך

כדי לראות את קטע הקוד הזה בהקשר של אפליקציית אינטרנט, אפשר לעיין בדוגמאות של Go ב-GitHub.

package alloydb

import (
	"database/sql"
	"fmt"
	"log"
	"os"

	// Note: If connecting using the App Engine Flex Go runtime, use
	// "github.com/jackc/pgx/stdlib" instead, since v4 requires
	// Go modules which are not supported by App Engine Flex.
	_ "github.com/jackc/pgx/v5/stdlib"
)

// connectTCPSocket initializes a TCP connection pool for an AlloyDB cluster.
func connectTCPSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Warning: %s environment variable not set.", k)
		}
		return v
	}
	// Note: Saving credentials in environment variables is convenient, but not
	// secure - consider a more secure solution such as
	// Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
	// keep secrets safe.
	var (
		dbUser    = mustGetenv("DB_USER")       // e.g. 'my-db-user'
		dbPwd     = mustGetenv("DB_PASS")       // e.g. 'my-db-password'
		dbTCPHost = mustGetenv("INSTANCE_HOST") // e.g. '127.0.0.1' or IP Address of Cluster
		dbPort    = mustGetenv("DB_PORT")       // e.g. '5432'
		dbName    = mustGetenv("DB_NAME")       // e.g. 'my-database'
	)

	dbURI := fmt.Sprintf("host=%s user=%s password=%s port=%s database=%s",
		dbTCPHost, dbUser, dbPwd, dbPort, dbName)

	// dbPool is the pool of database connections.
	dbPool, err := sql.Open("pgx", dbURI)
	if err != nil {
		return nil, fmt.Errorf("sql.Open: %v", err)
	}

	// ...

	return dbPool, nil
}

C#‎

כדי לראות את קטע הקוד הזה בהקשר של אפליקציית אינטרנט, עיינו ב-README ב-GitHub.

using Npgsql;
using System;

namespace CloudSql
{
    public class PostgreSqlTcp
    {
        public static NpgsqlConnectionStringBuilder NewPostgreSqlTCPConnectionString()
        {
            // Equivalent connection string:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new NpgsqlConnectionStringBuilder()
            {
                // Note: Saving credentials in environment variables is convenient, but not
                // secure - consider a more secure solution such as
                // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
                // keep secrets safe.
                Host = Environment.GetEnvironmentVariable("INSTANCE_HOST"),     // e.g. '127.0.0.1'
                // Set Host to 'cloudsql' when deploying to App Engine Flexible environment
                Username = Environment.GetEnvironmentVariable("DB_USER"), // e.g. 'my-db-user'
                Password = Environment.GetEnvironmentVariable("DB_PASS"), // e.g. 'my-db-password'
                Database = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'

                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = SslMode.Disable,
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Ruby

כדי לראות את קטע הקוד הזה בהקשר של אפליקציית אינטרנט, עיינו ב-README ב-GitHub.

development:
  adapter: postgresql
  # Configure additional properties here.
  username: <%= ENV["DB_USER"] %>  # e.g. "my-database-user"
  password: <%= ENV["DB_PASS"] %> # e.g. "my-database-password"
  database: <%= ENV.fetch("DB_NAME") { "vote_development" } %>
  host: <%= ENV.fetch("DB_HOST") { "127.0.0.1" }%> # '172.17.0.1' if deployed to GAE Flex
  port: <%= ENV.fetch("DB_PORT")  { 5432 }%>

PHP

כדי לראות את קטע הקוד הזה בהקשר של אפליקציית אינטרנט, עיינו ב-README ב-GitHub.

// $username = 'your_db_user';
// $password = 'yoursupersecretpassword';
// $dbName = 'your_db_name';
// $dbHost = "127.0.0.1";

// Connect using TCP
$dsn = sprintf('pgsql:dbname=%s;host=%s', $dbName, $dbHost);

// Connect to the database
$conn = new PDO($dsn, $username, $password, $connConfig);

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

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

הורדת הלקוח של Auth Proxy

Linux

‫64 ביט (AMD)

‫32 ביט (AMD)

‫64 ביט (ARM)

‫32 ביט (ARM)

macOS

ARM64

AMD64

Windows

64-ביט

32 סיביות

קובץ אימג' של Docker

מערכת הפעלה אחרת

בחירת חשבון המשתמש בניהול זהויות והרשאות גישה (IAM) והכנה שלו לאימות

הרשאות IAM נדרשות

הפיכת פרטי הכניסה של IAM לזמינים במארח הלקוח

מקורות אחרים של פרטי כניסה

איסוף של מזהי URI לחיבור למכונות AlloyDB

הפעלת הלקוח של שרת ה-proxy לאימות

שורת הפקודה

מאגר Docker

דוגמאות לסטארט-אפים

הפעלה בסיסית

הפעלה באמצעות חשבון שירות בניהול המשתמשים

הפעלה של חיבור לכמה מופעים

האזנה להפעלה ביציאות בהתאמה אישית

האזנה להפעלה בכתובת IP מותאמת אישית

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

psql

Python

Java

Node.js

המשך

C#‎

Ruby

PHP

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