חיבור באמצעות שרת proxy ל-Cloud SQL Auth

‫MySQL   |  PostgreSQL   |  SQL Server

בדף הזה מוסבר איך להתחבר למופע Cloud SQL באמצעות שרת proxy ל-Cloud SQL Auth.

מידע נוסף על האופן שבו שרת ה-Proxy ל-Cloud SQL Auth פועל זמין במאמר מידע על שרת ה-Proxy ל-Cloud SQL Auth.

סקירה כללית

השיטה המומלצת להתחברות למופע Cloud SQL היא באמצעות שרת proxy ל-Cloud SQL Auth. שרת proxy ל-Cloud SQL Auth:

• פועל עם נקודות קצה של כתובות IP ציבוריות ופרטיות
• מאמת את החיבורים באמצעות פרטי כניסה של משתמש או חשבון שירות
• עוטף את החיבור בשכבת הצפנה של SSL/TLS שמאושרת למכונה שלכם ב-Cloud SQL

חלק מהשירותים והאפליקציות משתמשים בשרת proxy ל-Cloud SQL Auth כדי לספק חיבורים לנתיבי כתובות IP ציבוריות עם הצפנה והרשאה, כולל: Google Cloud

• הסביבה הסטנדרטית של App Engine
• הסביבה הגמישה של App Engine
• Cloud Run

אפליקציות שפועלות ב- Google Kubernetes Engine יכולות להתחבר באמצעות Cloud SQL Auth Proxy.

הערה: כדי להתחבר מ-Google Kubernetes Engine, מומלץ להריץ את שרת ה-proxy ל-Cloud SQL Auth בתבנית sidecar, כ קונטיינר נוסף שמשותף עם הפוד של האפליקציה. מומלץ לעיין גם במדריך למתחילים שקשור לנושא.

במדריך למתחילים לשימוש בשרת proxy ל-Cloud SQL Auth יש מבוא בסיסי לשימוש בשרת.

אפשר גם להתחבר באמצעות לקוח psql ממחשב מקומי או מ-Compute Engine, עם או בלי שרת proxy ל-Cloud SQL Auth.

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

לפני שמתחברים למופע Cloud SQL, צריך לבצע את הפעולות הבאות:

1. • למשתמש או לחשבון שירות, מוודאים שיש לחשבון את התפקיד Cloud SQL Client. התפקיד הזה מכיל את ההרשאה cloudsql.instances.connect, שמאפשרת לחשבון משתמש להתחבר לכל המכונות של Cloud SQL בפרויקט.

     כניסה לדף IAM

   • אפשר לכלול תנאי IAM בקשירת מדיניות IAM שמעניקה לחשבון הרשאה להתחבר רק למופע ספציפי אחד של Cloud SQL.

2. מפעילים את Cloud SQL Admin API.

   תפקידים שנדרשים להפעלת ממשקי API

   כדי להפעיל ממשקי API, צריך את תפקיד ה-IAM 'אדמין של Service Usage' (roles/serviceusage.serviceUsageAdmin), שכולל את ההרשאה serviceusage.services.enable. איך מקצים תפקידים

   להפעלת ה-API

3. מתקינים ומפעילים את ה-CLI של gcloud.
4. זה שינוי אופציונלי. מתקינים את לקוח Docker של שרת proxy ל-Cloud SQL Auth.

הורדת שרת proxy ל-Cloud SQL Auth

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

אם מריצים את הפקודה ב-Linux או ב-Mac, אפשר למצוא את המידע הזה באמצעות הפקודה הבאה:

  uname -a
  

‏Linux‏ 64 סיביות

1. מורידים את שרת ה-proxy ל-Cloud SQL Auth:

   curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.22.1/cloud-sql-proxy.linux.amd64

2. הופכים את שרת ה-proxy ל-Cloud SQL Auth לקובץ הפעלה:

   chmod +x cloud-sql-proxy

‏Linux‏ 32 סיביות

1. מורידים את שרת ה-proxy ל-Cloud SQL Auth:

   curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.22.1/cloud-sql-proxy.linux.386

2. אם הפקודה curl לא נמצאה, מריצים את הפקודה sudo apt install curl וחוזרים על פקודת ההורדה.
3. הופכים את שרת ה-proxy ל-Cloud SQL Auth לקובץ הפעלה:

   chmod +x cloud-sql-proxy

macOS‏ 64 סיביות

1. מורידים את שרת ה-proxy ל-Cloud SQL Auth:

   curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.22.1/cloud-sql-proxy.darwin.amd64

2. הופכים את שרת ה-proxy ל-Cloud SQL Auth לקובץ הפעלה:

   chmod +x cloud-sql-proxy

Mac M1

1. מורידים את שרת ה-proxy ל-Cloud SQL Auth:

     curl -o cloud-sql-proxy https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.22.1/cloud-sql-proxy.darwin.arm64
     

2. הופכים את שרת ה-proxy ל-Cloud SQL Auth לקובץ הפעלה:

     chmod +x cloud-sql-proxy
     

‏Windows‏ 64 סיביות

לוחצים לחיצה ימנית על https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.22.1/cloud-sql-proxy.x64.exe ובוחרים באפשרות שמירת קישור בשם כדי להוריד את שרת ה-proxy ל-Cloud SQL Auth. משנים את שם הקובץ ל-cloud-sql-proxy.exe.

‏Windows‏ 32 סיביות

לוחצים לחיצה ימנית על https://storage.googleapis.com/cloud-sql-connectors/cloud-sql-proxy/v2.22.1/cloud-sql-proxy.x86.exe ובוחרים באפשרות שמירת קישור בשם כדי להוריד את שרת ה-proxy ל-Cloud SQL Auth. משנים את שם הקובץ ל-cloud-sql-proxy.exe.

קובץ אימג' של Docker לשרת proxy ל-Cloud SQL Auth

לשרת ה-proxy ל-Cloud SQL Auth יש תמונות קונטיינר שונות, כמו distroless, alpine ו-buster. קובץ האימג' של קונטיינר ברירת המחדל של שרת proxy ל-Cloud SQL Auth משתמש ב-distroless, שלא מכיל מעטפת. אם אתם צריכים מעטפת או כלים קשורים, אתם יכולים להוריד תמונה שמבוססת על alpine או על buster. מידע נוסף זמין במאמר תמונות קונטיינר של Cloud SQL Auth Proxy.

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

docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.22.1

הערה: שרת ה-proxy ל-Cloud SQL Auth משתמש במאגר שתומך בדומיין gcr.io, אבל מציג תמונות מ-Artifact Registry. מידע נוסף זמין במאמר בנושא מעבר מ-Container Registry.

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

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

הפעלת שרת proxy ל-Cloud SQL Auth

בהתאם לשפה ולסביבה שלכם, אתם יכולים להפעיל את שרת ה-proxy ל-Cloud SQL Auth באמצעות שקעי TCP, שקעי Unix או קובץ אימג' של Docker של שרת ה-proxy ל-Cloud SQL Auth. קובץ הבינארי של שרת ה-proxy ל-Cloud SQL Auth מתחבר למכונה אחת או יותר של Cloud SQL שצוינו בשורת הפקודה, ופותח חיבור מקומי כ-TCP או כ-Unix socket. אפליקציות ושירותים אחרים, כמו קוד האפליקציה או כלי לקוח לניהול מסדי נתונים, יכולים להתחבר למכונות של Cloud SQL דרך חיבורי TCP או Unix socket.

אזהרה: צריך להיזהר כשמבצעים binding של שרת proxy ל-Cloud SQL Auth לממשק חיצוני. כל מי שיש לו גישה לממשק או ליציאה האלה יקבל הרשאה להתחבר למופע שלכם.

שקעי TCP

בחיבורי TCP, שרת ה-proxy ל-Cloud SQL Auth מאזין ל-localhost(127.0.0.1) כברירת מחדל. לכן, כשמציינים --port PORT_NUMBER למופע, החיבור המקומי הוא בכתובת 127.0.0.1:PORT_NUMBER.

אפשר גם לציין כתובת אחרת לחיבור המקומי. לדוגמה, כך מגדירים את שרת ה-proxy ל-Cloud SQL Auth להאזין בכתובת 0.0.0.0:1234 לחיבור המקומי:

./cloud-sql-proxy --address 0.0.0.0 --port 1234 INSTANCE_CONNECTION_NAME

1. מעתיקים את INSTANCE_CONNECTION_NAME. אפשר למצוא את כתובת ה-IP בדף Overview של המופע במסוףGoogle Cloud או על ידי הפעלת הפקודה הבאה:

       gcloud sql instances describe INSTANCE_NAME --format='value(connectionName)'

   לדוגמה: myproject:myregion:myinstance.

2. אם למכונה מוגדרות כתובות IP ציבוריות ופרטיות, ואתם רוצים ששרת proxy ל-Cloud SQL Auth ישתמש בכתובת IP פרטית, אתם צריכים לספק את האפשרות הבאה כשמפעילים את שרת proxy ל-Cloud SQL Auth:

   --private-ip

3. אם אתם משתמשים בחשבון שירות כדי לאמת את שרת ה-proxy ל-Cloud SQL Auth, שימו לב למיקום במכונת הלקוח של קובץ המפתח הפרטי שנוצר כשנוצר חשבון השירות.
4. מפעילים את שרת ה-proxy ל-Cloud SQL Auth.

   מחרוזות אפשריות להפעלת שרת proxy ל-Cloud SQL Auth:

   • שימוש באימות Cloud SDK:

     ./cloud-sql-proxy --port 5432 INSTANCE_CONNECTION_NAME

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

     ./cloud-sql-proxy \
     --credentials-file PATH_TO_KEY_FILE INSTANCE_CONNECTION_NAME &

   מידע נוסף על האפשרויות של שרת proxy ל-Cloud SQL Auth זמין במאמר אפשרויות לאימות שרת proxy ל-Cloud SQL Auth.

שקעי Unix

הערה: ה-Cloud SQL Auth Proxy לא תומך כרגע בשקעי Unix ב-Windows, ולכן האפשרות הזו זמינה רק בפלטפורמות Linux ו-macOS.

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

הערה: בתקן של PostgreSQL נדרש הסיומת ‎.s.PGSQL.5432 בנתיב של שקע (socket). חלק מהספריות מוסיפות את הסיומת הזו באופן אוטומטי, אבל בספריות אחרות צריך לציין את נתיב הסוקט באופן הבא:

  /cloudsql/INSTANCE_CONNECTION_NAME/.s.PGSQL.5432
  

כדי ליצור ולשלוח נתונים דרך שקע Unix, ספריית היעד צריכה להתקיים, ולשרת ה-proxy ל-Cloud SQL Auth ולאפליקציה צריכות להיות הרשאות קריאה וכתיבה אליה.

1. מעתיקים את INSTANCE_CONNECTION_NAME. אפשר למצוא את כתובת ה-IP בדף Overview של המופע במסוףGoogle Cloud או על ידי הפעלת הפקודה הבאה:

       gcloud sql instances describe INSTANCE_NAME --format='value(connectionName)'

   לדוגמה: myproject:myregion:myinstance.

2. יוצרים את הספרייה שבה יאוחסנו שקעי Cloud SQL Auth Proxy:

   sudo mkdir /cloudsql; sudo chmod 777 /cloudsql

3. אם אתם משתמשים בחשבון שירות כדי לאמת את שרת ה-proxy ל-Cloud SQL Auth, שימו לב למיקום במכונת הלקוח של קובץ המפתח הפרטי שנוצר כשנוצר חשבון השירות.
4. פותחים חלון טרמינל חדש ב-Cloud Shell ומפעילים את Cloud SQL Auth Proxy.

   מחרוזות אפשריות להפעלת שרת proxy ל-Cloud SQL Auth:

   • שימוש באימות של Google Cloud SDK:

     ./cloud-sql-proxy --unix-socket /cloudsql INSTANCE_CONNECTION_NAME &

   • שימוש בחשבון שירות:

       ./cloud-sql-proxy --unix-socket /cloudsql
       --credentials-file PATH_TO_KEY_FILE INSTANCE_CONNECTION_NAME &

   מפעילים את Cloud SQL Auth Proxy במסוף Cloud Shell משלו כדי לעקוב אחרי הפלט שלו בלי שהוא יתערבב עם הפלט מתוכניות אחרות.

   מידע נוסף על האפשרויות של שרת proxy ל-Cloud SQL Auth זמין במאמר אפשרויות לאימות שרת proxy ל-Cloud SQL Auth.

   הערה: כשמשתמשים בשקע Unix כדי להתחבר ל-Cloud SQL באמצעות שרת proxy ל-Cloud SQL Auth, צריך לוודא שאורך שם הקובץ של השקע לא חורג מהמגבלה של המערכת. זה תלוי במערכת, אבל בדרך כלל זה בין 91 ל-108 תווים. ב-Linux, האורך מוגדר בדרך כלל כ-108, ואפשר להשתמש בפקודה הבאה כדי לבדוק:

   cat /usr/include/linux/un.h | grep "define UNIX_PATH_MAX"

Docker

כדי להריץ את שרת ה-proxy ל-Cloud SQL Auth במאגר Docker, משתמשים בקובץ האימג' של Docker של שרת ה-proxy ל-Cloud SQL Auth שזמין ב-Google Container Registry.

אפשר להפעיל את Cloud SQL Auth Proxy באמצעות שקעי TCP או שקעי Unix, עם הפקודות שמוצגות בהמשך. האפשרויות משתמשות ב-INSTANCE_CONNECTION_NAME כמחרוזת החיבור כדי לזהות מכונה של Cloud SQL. אפשר למצוא את INSTANCE_CONNECTION_NAME בדף Overview של המופע במסוףGoogle Cloud , או על ידי הפעלת הפקודה הבאה:

gcloud sql instances describe INSTANCE_NAME

.

לדוגמה: myproject:myregion:myinstance.

הערה: שרת ה-proxy ל-Cloud SQL Auth לא תומך בהאזנה לשקעי דומיין של Unix ב-Windows.

בהתאם לשפה ולסביבה שלכם, אתם יכולים להפעיל את שרת ה-proxy ל-Cloud SQL Auth באמצעות שקעי TCP או שקעי Unix. אין תמיכה בשקעי Unix באפליקציות שנכתבו בשפת התכנות Java או בסביבת Windows.

שימוש בשקעי TCP

docker run -d \\
  -v PATH_TO_KEY_FILE:/path/to/service-account-key.json \\
  -p 127.0.0.1:5432:5432 \\
  gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.22.1 \\
  --address 0.0.0.0 --port 5432 \\
  --credentials-file /path/to/service-account-key.json INSTANCE_CONNECTION_NAME

אם אתם משתמשים בפרטי הכניסה שסופקו על ידי מכונת Compute Engine, אל תכללו את הפרמטר --credentials-file ואת השורה -v PATH_TO_KEY_FILE:/path/to/service-account-key.json.

תמיד מציינים את הקידומת 127.0.0.1 ב-‎-p כדי ששרת ה-proxy ל-Cloud SQL Auth לא ייחשף מחוץ למארח המקומי. הערך '0.0.0.0' בפרמטר instances נדרש כדי לאפשר גישה ליציאה מחוץ למאגר Docker.

שימוש בסוקטים של Unix

docker run -d -v /cloudsql:/cloudsql \\
  -v PATH_TO_KEY_FILE:/path/to/service-account-key.json \\
  gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.22.1 --unix-socket=/cloudsql \\
  --credentials-file /path/to/service-account-key.json INSTANCE_CONNECTION_NAME

אם אתם משתמשים בפרטי הכניסה שסופקו על ידי מכונת Compute Engine, אל תכללו את הפרמטר --credentials-file ואת השורה -v PATH_TO_KEY_FILE:/path/to/service-account-key.json.

אם אתם משתמשים באימג' שעבר אופטימיזציה לקונטיינר, השתמשו בספרייה שאפשר לכתוב בה במקום /cloudsql, לדוגמה:

-v /mnt/stateful_partition/cloudsql:/cloudsql

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

התחברות ללקוח psql

‫Debian/Ubuntu

מתקינים את לקוח psql ממנהל החבילות:

sudo apt-get update
sudo apt-get install postgresql-client

‫CentOS/RHEL

מתקינים את לקוח psql ממנהל החבילות:

sudo yum install postgresql

openSUSE

מתקינים את לקוח psql ממנהל החבילות:

sudo zypper install postgresql

פלטפורמות אחרות

1. מורידים את PostgreSQL Core Distribution לפלטפורמה שלכם מדף ההורדות של PostgreSQL. ‫
   Core Distribution כולל את לקוח psql.
2. מתקינים את מסד הנתונים PostgreSQL לפי ההוראות בדף ההורדה.

מחרוזת החיבור שבה אתם משתמשים תלויה בדרך שבה הפעלתם את שרת ה-proxy ל-Cloud SQL Auth: באמצעות שקע TCP, שקע UNIX או Docker.

שקעי TCP

1. מפעילים את לקוח psql:

   psql "host=127.0.0.1 sslmode=disable dbname=DB_NAME user=USERNAME"

   למרות שהפרמטר sslmode מוגדר לערך disable, שרת ה-proxy ל-Cloud SQL Auth מספק חיבור מוצפן.

   כשמתחברים באמצעות שקעי TCP, מתבצעת גישה לשרת ה-proxy ל-Cloud SQL Auth דרך 127.0.0.1.

2. אם מופיעה בקשה, מזינים את הסיסמה.
3. מופיעה ההנחיה של psql.

שימוש בסוקטים של Unix

1. מפעילים את לקוח psql:

   psql "sslmode=disable host=/cloudsql/INSTANCE_CONNECTION_NAME dbname=DB_NAME user=USERNAME"

   למרות שהפרמטר sslmode מוגדר לערך disable, שרת ה-proxy ל-Cloud SQL Auth מספק חיבור מוצפן.

2. מזינים את הסיסמה.
3. מופיעה ההנחיה של psql.

דרושה לך עזרה? לקבלת עזרה בפתרון בעיות בשרת ה-proxy, אפשר לעיין במאמר בנושא פתרון בעיות בחיבורים של שרת proxy ל-Cloud SQL Auth או בדף תמיכה ב-Cloud SQL.

חיבור לאפליקציה

אפשר להתחבר לשרת proxy ל-Cloud SQL Auth מכל שפה שמאפשרת להתחבר לשקע Unix או TCP. בהמשך מופיעים קטעי קוד מתוך דוגמאות מלאות ב-GitHub, שיעזרו לכם להבין איך הם פועלים יחד באפליקציה שלכם.

חיבור באמצעות TCP

הצהרת הפעלה של שרת proxy ל-Cloud SQL Auth:

./cloud-sql-proxy INSTANCE_CONNECTION_NAME &

Python

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

import os
import ssl

import sqlalchemy


def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    """Initializes a TCP connection pool for a Cloud SQL instance of Postgres."""
    # 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.
    db_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>@<db_host>:<db_port>/<db_name>
        sqlalchemy.engine.url.URL.create(
            drivername="postgresql+pg8000",
            username=db_user,
            password=db_pass,
            host=db_host,
            port=db_port,
            database=db_name,
        ),
        # ...
    )
    return pool

Java

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

הערה:

• המשתנה CLOUD_SQL_CONNECTION_NAME צריך להיות מיוצג בתור ‎<MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME>
• השימוש בארגומנט ipTypes=PRIVATE יגרום ל-SocketFactory להתחבר עם כתובת IP פרטית שמשויכת למופע.
• אפשר לעיין בדרישות לגבי גרסת JDBC socket factory לקובץ pom.xml.

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>
    // See the link below for more info on building a JDBC URL for the Cloud SQL JDBC Socket Factory
    // https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory#creating-the-jdbc-url

    // 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

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

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

// createTcpPool initializes a TCP connection pool for a Cloud SQL
// instance of Postgres.
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);
};

המשך

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

package cloudsql

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

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

// connectTCPSocket initializes a TCP connection pool for a Cloud SQL
// instance of Postgres.
func connectTCPSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Fatal Error in connect_tcp.go: %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' ('172.17.0.1' if deployed to GAE Flex)
		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: %w", 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.

tcp: &tcp
  adapter: postgresql
  # Configure additional properties here.
  # 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.
  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("INSTANCE_HOST") { "127.0.0.1" }%> # '172.17.0.1' if deployed to GAE Flex
  port: <%= ENV.fetch("DB_PORT") { 5432 }%>

PHP

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

namespace Google\Cloud\Samples\CloudSQL\Postgres;

use PDO;
use PDOException;
use RuntimeException;
use TypeError;

class DatabaseTcp
{
    public static function initTcpDatabaseConnection(): PDO
    {
        try {
            // 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.
            $username = getenv('DB_USER'); // e.g. 'your_db_user'
            $password = getenv('DB_PASS'); // e.g. 'your_db_password'
            $dbName = getenv('DB_NAME'); // e.g. 'your_db_name'
            $instanceHost = getenv('INSTANCE_HOST'); // e.g. '127.0.0.1' ('172.17.0.1' for GAE Flex)

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

            // Connect to the database
            $conn = new PDO(
                $dsn,
                $username,
                $password,
                # ...
            );
        } catch (TypeError $e) {
            throw new RuntimeException(
                sprintf(
                    'Invalid or missing configuration! Make sure you have set ' .
                        '$username, $password, $dbName, and $instanceHost (for TCP mode). ' .
                        'The PHP error was %s',
                    $e->getMessage()
                ),
                $e->getCode(),
                $e
            );
        } catch (PDOException $e) {
            throw new RuntimeException(
                sprintf(
                    'Could not connect to the Cloud SQL Database. Check that ' .
                        'your username and password are correct, that the Cloud SQL ' .
                        'proxy is running, and that the database exists and is ready ' .
                        'for use. For more assistance, refer to %s. The PDO error was %s',
                    'https://cloud.google.com/sql/docs/postgres/connect-external-app',
                    $e->getMessage()
                ),
                $e->getCode(),
                $e
            );
        }

        return $conn;
    }
}

חיבור באמצעות שקעי Unix

הצהרת הפעלה של שרת proxy ל-Cloud SQL Auth:

./cloud-sql-proxy --unix-socket /cloudsql INSTANCE_CONNECTION_NAME &

Python

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

import os

import sqlalchemy


def connect_unix_socket() -> sqlalchemy.engine.base.Engine:
    """Initializes a Unix socket connection pool for a Cloud SQL instance of Postgres."""
    # 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.
    db_user = os.environ["DB_USER"]  # e.g. 'my-database-user'
    db_pass = os.environ["DB_PASS"]  # e.g. 'my-database-password'
    db_name = os.environ["DB_NAME"]  # e.g. 'my-database'
    unix_socket_path = os.environ[
        "INSTANCE_UNIX_SOCKET"
    ]  # e.g. '/cloudsql/project:region:instance'

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # postgresql+pg8000://<db_user>:<db_pass>@/<db_name>
        #                         ?unix_sock=<INSTANCE_UNIX_SOCKET>/.s.PGSQL.5432
        # Note: Some drivers require the `unix_sock` query parameter to use a different key.
        # For example, 'psycopg2' uses the path set to `host` in order to connect successfully.
        sqlalchemy.engine.url.URL.create(
            drivername="postgresql+pg8000",
            username=db_user,
            password=db_pass,
            database=db_name,
            query={"unix_sock": f"{unix_socket_path}/.s.PGSQL.5432"},
        ),
        # ...
    )
    return pool

Java

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

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

public class ConnectorConnectionPoolFactory 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 INSTANCE_CONNECTION_NAME =
      System.getenv("INSTANCE_CONNECTION_NAME");
  private static final String INSTANCE_UNIX_SOCKET = System.getenv("INSTANCE_UNIX_SOCKET");
  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");

  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:///<DB_NAME>?cloudSqlInstance=<INSTANCE_CONNECTION_NAME>&
    // socketFactory=com.google.cloud.sql.postgres.SocketFactory&user=<DB_USER>&password=<DB_PASS>
    // See the link below for more info on building a JDBC URL for the Cloud SQL JDBC Socket Factory
    // https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory#creating-the-jdbc-url

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

    config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.postgres.SocketFactory");
    config.addDataSourceProperty("cloudSqlInstance", INSTANCE_CONNECTION_NAME);

    // Unix sockets are not natively supported in Java, so it is necessary to use the Cloud SQL
    // Java Connector to connect. When setting INSTANCE_UNIX_SOCKET, the connector will 
    // call an external package that will enable Unix socket connections.
    // Note: For Java users, the Cloud SQL Java Connector can provide authenticated connections
    // which is usually preferable to using the Cloud SQL Proxy with Unix sockets.
    // See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.
    if (INSTANCE_UNIX_SOCKET != null) {
      config.addDataSourceProperty("unixSocketPath", INSTANCE_UNIX_SOCKET);
    }


    // cloudSqlRefreshStrategy set to "lazy" is used to perform a
    // refresh when needed, rather than on a scheduled interval.
    // This is recommended for serverless environments to
    // avoid background refreshes from throttling CPU.
    config.addDataSourceProperty("cloudSqlRefreshStrategy", "lazy");

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

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

Node.js

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

const Knex = require('knex');

// createUnixSocketPool initializes a Unix socket connection pool for
// a Cloud SQL instance of Postgres.
const createUnixSocketPool = 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.
  return Knex({
    client: 'pg',
    connection: {
      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'
      host: process.env.INSTANCE_UNIX_SOCKET, // e.g. '/cloudsql/project:region:instance'
    },
    // ... Specify additional properties here.
    ...config,
  });
};

C#‎

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

using Npgsql;
using System;

namespace CloudSql
{
    public class PostgreSqlUnix
    {
        public static NpgsqlConnectionStringBuilder NewPostgreSqlUnixSocketConnectionString()
        {
            // Equivalent connection string:
            // "Server=<INSTANCE_UNIX_SOCKET>;Uid=<DB_USER>;Pwd=<DB_PASS>;Database=<DB_NAME>"
            var connectionString = new NpgsqlConnectionStringBuilder()
            {
                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = SslMode.Disable,

                // 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_UNIX_SOCKET"), // e.g. '/cloudsql/project:region:instance'
                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'
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

המשך

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

package cloudsql

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

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

// connectUnixSocket initializes a Unix socket connection pool for
// a Cloud SQL instance of Postgres.
func connectUnixSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Fatal Error in connect_unix.go: %s environment variable not set.\n", 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'
		unixSocketPath = mustGetenv("INSTANCE_UNIX_SOCKET") // e.g. '/cloudsql/project:region:instance'
		dbName         = mustGetenv("DB_NAME")              // e.g. 'my-database'
	)

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

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

	// ...

	return dbPool, nil
}

Ruby

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

unix: &unix
  adapter: postgresql
  # Configure additional properties here.
  # 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.
  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" } %>
  # Specify the Unix socket path as host
  host: "<%= ENV["INSTANCE_UNIX_SOCKET"] %>"

PHP

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

namespace Google\Cloud\Samples\CloudSQL\Postgres;

use PDO;
use PDOException;
use RuntimeException;
use TypeError;

class DatabaseUnix
{
    public static function initUnixDatabaseConnection(): PDO
    {
        try {
            // 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.
            $username = getenv('DB_USER'); // e.g. 'your_db_user'
            $password = getenv('DB_PASS'); // e.g. 'your_db_password'
            $dbName = getenv('DB_NAME'); // e.g. 'your_db_name'
            $instanceUnixSocket = getenv('INSTANCE_UNIX_SOCKET'); // e.g. '/cloudsql/project:region:instance'

            // Connect using UNIX sockets
            $dsn = sprintf(
                'pgsql:dbname=%s;host=%s',
                $dbName,
                $instanceUnixSocket
            );

            // Connect to the database.
            $conn = new PDO(
                $dsn,
                $username,
                $password,
                # ...
            );
        } catch (TypeError $e) {
            throw new RuntimeException(
                sprintf(
                    'Invalid or missing configuration! Make sure you have set ' .
                        '$username, $password, $dbName, ' .
                        'and $instanceUnixSocket (for UNIX socket mode). ' .
                        'The PHP error was %s',
                    $e->getMessage()
                ),
                (int) $e->getCode(),
                $e
            );
        } catch (PDOException $e) {
            throw new RuntimeException(
                sprintf(
                    'Could not connect to the Cloud SQL Database. Check that ' .
                        'your username and password are correct, that the Cloud SQL ' .
                        'proxy is running, and that the database exists and is ready ' .
                        'for use. For more assistance, refer to %s. The PDO error was %s',
                    'https://cloud.google.com/sql/docs/postgres/connect-external-app',
                    $e->getMessage()
                ),
                (int) $e->getCode(),
                $e
            );
        }

        return $conn;
    }
}

נושאים נוספים

ארגומנטים בשורת הפקודה של שרת proxy ל-Cloud SQL Auth

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

./cloud-sql-proxy --help

דוגמאות נוספות לשימוש באפשרויות של שורת הפקודה של שרת proxy ל-Cloud SQL Auth מופיעות בקובץ README במאגר GitHub של שרת proxy ל-Cloud SQL Auth.

אפשרויות לאימות שרת ה-Proxy ל-Cloud SQL Auth

כשמאמתים את שרת ה-proxy ל-Cloud SQL Auth, מאפשרים לו לגשת אלGoogle Cloud בשם האפליקציה, באמצעות קבוצה של פרטי כניסה של Google. האימות הזה נפרד מאימות משתמשים במסד הנתונים. אימות משתמשים במסד נתונים באמצעות IAM משולב עם שרת proxy ל-Cloud SQL Auth.

בכל האפשרויות האלה נעשה שימוש ב-INSTANCE_CONNECTION_NAME כמחרוזת החיבור כדי לזהות מופע של Cloud SQL. אפשר למצוא את INSTANCE_CONNECTION_NAME בדף Overview של המופע במסוףGoogle Cloud , או על ידי הפעלת הפקודה הבאה:

gcloud sql instances describe --project PROJECT_ID INSTANCE_CONNECTION_NAME.

לדוגמה: gcloud sql instances describe --project myproject myinstance .

חלק מהאפשרויות האלה משתמשות בקובץ פרטי כניסה בפורמט JSON שכולל את המפתח הפרטי של RSA לחשבון. הוראות ליצירת קובץ JSON של פרטי כניסה לחשבון שירות זמינות במאמר יצירת חשבון שירות.

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

1. פרטי הכניסה שסופקו באמצעות הדגל credentials-file.

   משתמשים בחשבון שירות כדי ליצור ולהוריד את קובץ ה-JSON המשויך, ומגדירים את האפשרות --credentials-file לנתיב של הקובץ כשמפעילים את שרת ה-proxy ל-Cloud SQL Auth. לחשבון השירות צריכות להיות ההרשאות הנדרשות למכונת Cloud SQL.

   כדי להשתמש באפשרות הזו בשורת הפקודה, מפעילים את הפקודה cloud-sql-proxy עם הדגל --credentials-file שמוגדר לנתיב ולשם הקובץ של קובץ JSON עם פרטי כניסה. הנתיב יכול להיות מוחלט או יחסי לספריית העבודה הנוכחית. לדוגמה:

   ./cloud-sql-proxy --credentials-file PATH_TO_KEY_FILE \
   INSTANCE_CONNECTION_NAME
     

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

   מידע נוסף על התפקידים שנתמכים ב-Cloud SQL זמין במאמר תפקידי IAM ל-Cloud SQL.

2. פרטי הכניסה שסופקו על ידי אסימון גישה.

   יוצרים אסימון גישה ומפעילים את הפקודה cloud-sql-proxy עם האפשרות --token שמוגדרת לאסימון גישה מסוג OAuth 2.0. לדוגמה:

   ./cloud-sql-proxy --token ACCESS_TOKEN \
   INSTANCE_CONNECTION_NAME
     

3. פרטי הכניסה שסופקו על ידי משתנה סביבה.

   האפשרות הזו דומה לשימוש בדגל --credentials-file, אבל במקום להשתמש בארגומנט --credentials-file בשורת הפקודה, מציינים את קובץ פרטי הכניסה בפורמט JSON שהגדרתם במשתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS.

4. פרטי כניסה מלקוח מאומת של ה-CLI של gcloud.

   אם התקנתם את ה-CLI של gcloud ואתם מאומתים באמצעות החשבון האישי שלכם, שרת ה-Proxy ל-Cloud SQL Auth יכול להשתמש באותם פרטי כניסה לחשבון. השיטה הזו שימושית במיוחד להקמה של סביבת פיתוח.

   כדי לאפשר ל-Cloud SQL Auth Proxy להשתמש בפרטי הכניסה שלכם ב-CLI של gcloud, משתמשים בפקודה הבאה כדי לאמת את ה-CLI של gcloud:

   gcloud auth application-default login

5. פרטי הכניסה שמשויכים למכונת Compute Engine.

   אם מתחברים ל-Cloud SQL ממכונת Compute Engine, שרת ה-proxy ל-Cloud SQL Auth יכול להשתמש בחשבון השירות שמשויך למכונת Compute Engine. אם לחשבון השירות יש את ההרשאות הנדרשות למכונה של Cloud SQL, שרת ה-proxy ל-Cloud SQL Auth מבצע אימות בהצלחה.

   אם המכונה ב-Compute Engine נמצאת באותו פרויקט כמו המכונה ב-Cloud SQL, לחשבון השירות שמוגדר כברירת מחדל למכונה ב-Compute Engine יש את ההרשאות הנדרשות לאימות שרת ה-proxy ל-Cloud SQL Auth. אם שני המקרים נמצאים בפרויקטים שונים, צריך להוסיף את חשבון השירות של מכונת Compute Engine לפרויקט שמכיל את מכונת Cloud SQL.

6. חשבון השירות שמוגדר כברירת מחדל בסביבה

   אם Cloud SQL Auth Proxy לא מוצא פרטי כניסה באף אחד מהמקומות שצוינו קודם, הוא פועל לפי הלוגיקה שמתועדת במאמר הגדרת אימות לאפליקציות בייצור משרת לשרת. חלק מהסביבות (כמו Compute Engine, ‏ App Engine ועוד) מספקות חשבון שירות שמוגדר כברירת מחדל, והאפליקציה יכולה להשתמש בו כדי לבצע אימות כברירת מחדל. אם משתמשים בחשבון שירות שמוגדר כברירת מחדל, צריך לוודא שיש לו את ההרשאות שמפורטות במאמר בנושא תפקידים והרשאות. למידע נוסף על הגישה של Google Cloud לאימות, אפשר לעיין במאמר סקירה כללית על אימות.

יצירה של חשבון שירות

אם אתם מתחברים מ-Compute Engine, ודאו שלמכונה הווירטואלית יש את ההרשאות המתאימות scope כדי להתחבר באמצעות Cloud SQL Admin API.

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

• https://www.googleapis.com/auth/sqlservice.admin
• https://www.googleapis.com/auth/cloud-platform

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

   כניסה לדף Service accounts

2. בוחרים את הפרויקט שמכיל את מופע Cloud SQL.
3. לוחצים על יצירת חשבון שירות.
4. בשדה Service account name, מזינים שם תיאורי לחשבון השירות.
5. משנים את מזהה חשבון השירות לערך ייחודי וקל לזיהוי, ואז לוחצים על יצירה והמשך.
6. לוחצים על השדה Select a role (בחירת תפקיד) ובוחרים באחד מהתפקידים הבאים:
   • ‫Cloud SQL > Cloud SQL Client
   • ‫Cloud SQL > Cloud SQL Editor
   • ‫Cloud SQL > Cloud SQL Admin
   הערה: כדי ליצור חשבון שירות עם ההרשאות הנדרשות, צריך את ההרשאה resourcemanager.projects.setIamPolicy. ההרשאה הזו כלולה בתפקידים Project Owner, 'אדמין IAM בפרויקט' ו-Organization Administrator.
   צריך גם להפעיל את Cloud SQL Admin API. אם אתם משתמשים בתפקידים הישנים בפרויקט (צופה, עורך, בעלים), לחשבון השירות צריך להיות לפחות תפקיד עורך.
7. לוחצים על Done כדי לסיים ליצור את חשבון השירות.
8. לוחצים על תפריט הפעולות של חשבון השירות החדש ובוחרים באפשרות ניהול מפתחות.
9. לוחצים על התפריט הנפתח Add key ואז על Create new key.
10. מוודאים שסוג המפתח הוא JSON ולוחצים על Create.

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

שימוש בשרת proxy ל-Cloud SQL Auth עם כתובת IP פרטית

כדי להתחבר למכונת Cloud SQL באמצעות כתובת IP פרטית, שרת ה-proxy ל-Cloud SQL Auth צריך להיות במשאב עם גישה לאותה רשת VPC כמו המכונה.

שרת ה-proxy ל-Cloud SQL Auth משתמש בכתובת IP כדי ליצור חיבור למכונה שלכם ב-Cloud SQL. כברירת מחדל, שרת proxy ל-Cloud SQL Auth מנסה להתחבר באמצעות כתובת IPv4 ציבורית.

אם למכונת Cloud SQL יש רק כתובת IP פרטית, או אם למכונה יש גם כתובת IP ציבורית וגם כתובת IP פרטית, ואתם רוצים ששרת ה-proxy ל-Cloud SQL Auth ישתמש בכתובת ה-IP הפרטית, אתם צריכים לספק את האפשרות הבאה כשאתם מפעילים את שרת ה-proxy ל-Cloud SQL Auth:

--private-ip

שימוש בשרת proxy ל-Cloud SQL Auth כדי להתחבר לנקודת קצה לכתיבה

אפשר להשתמש בשרת proxy ל-Cloud SQL Auth כדי להתחבר למכונה ראשית של Cloud SQL שהוגדרה עם נקודת קצה לכתיבה. נקודת קצה לכתיבה היא שם שירות DNS גלובלי שבו אפשר להשתמש לחיבורים במקום בכתובת IP לצורך שחזור מתקדם אחרי אסון (DR), כמו ביצוע מעבר לגיבוי או פעולת מעבר. אם מתרחש מעבר לגיבוי או מעבר לגיבוי פעיל של העותק המשוכפל של המופע הראשי, Cloud SQL Auth Proxy מזהה באופן אוטומטי שינויים ברשומת ה-DNS.

למידע נוסף על השימוש בשרת proxy ל-Cloud SQL Auth כדי להתחבר לנקודת קצה לכתיבה, אפשר לעיין במאמר חיבור לקוחות של מסד נתונים למכונות באמצעות שרת proxy ל-Cloud SQL Auth או מחברי שפה של Cloud SQL.

שימוש בשרת proxy ל-Cloud SQL Auth עם מכונות שמופעל בהן Private Service Connect

אפשר להשתמש בשרת proxy ל-Cloud SQL Auth כדי להתחבר למכונה של Cloud SQL עם Private Service Connect מופעל.

שרת ה-proxy ל-Cloud SQL Auth הוא מחבר שמספק גישה מאובטחת למכונה הזו בלי צורך ברשתות מורשות או בהגדרת SSL.

כדי לאפשר חיבורי לקוח של Cloud SQL Auth Proxy, צריך להגדיר רשומת DNS שתתאים לשם ה-DNS המומלץ שמופיע עבור המכונה. רשומת ה-DNS היא מיפוי בין משאב DNS לבין שם דומיין.

מידע נוסף על שימוש בשרת proxy ל-Cloud SQL Auth כדי להתחבר למכונות עם Private Service Connect מופעל זמין במאמר חיבור באמצעות שרת proxy ל-Cloud SQL Auth.

הפעלת שרת proxy ל-Cloud SQL Auth בתהליך נפרד

הפעלת שרת ה-proxy ל-Cloud SQL Auth בתהליך נפרד של מסוף Cloud Shell יכולה להיות שימושית, כדי למנוע ערבוב של הפלט של המסוף עם פלט מתוכניות אחרות. כדי להפעיל את שרת ה-proxy ל-Cloud SQL Auth בתהליך נפרד, משתמשים בתחביר שמוצג בהמשך.

Linux

ב-Linux או ב-macOS, משתמשים ב-& בסוף שורת הפקודה כדי להפעיל את Cloud SQL Auth Proxy בתהליך נפרד:

./cloud-sql-proxy INSTANCE_CONNECTION_NAME
  --credentials-file PATH_TO_KEY_FILE &

Windows

ב-Windows PowerShell, משתמשים בפקודה Start-Process כדי להפעיל את שרת ה-proxy ל-Cloud SQL Auth בתהליך נפרד:

Start-Process --filepath "cloud-sql-proxy.exe"
  --ArgumentList "
  --credentials-file PATH_TO_KEY_FILEINSTANCE_CONNECTION_NAME"

הפעלת שרת proxy ל-Cloud SQL Auth בקונטיינר Docker

כדי להריץ את Cloud SQL Auth Proxy במאגר Docker, משתמשים בקובץ האימג' של Cloud SQL Auth Proxy Docker שזמין ב-Google Container Registry. ניתן להתקין את קובץ אימג' של Docker של Cloud SQL Auth Proxy באמצעות הפקודה הבאה:

docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.22.1

אפשר להפעיל את Cloud SQL Auth Proxy באמצעות שקעי TCP או שקעי Unix, עם הפקודות שמוצגות בהמשך.

הערה: שקעי Unix לא נתמכים באפליקציות שנכתבו בשפת התכנות Java או בסביבת Windows.

שקעי TCP

    docker run -d \
      -v PATH_TO_KEY_FILE:/path/to/service-account-key.json \
      -p 127.0.0.1:5432:5432 \
      gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.22.1 \
      --address 0.0.0.0 \
      --credentials-file /path/to/service-account-key.json \
      INSTANCE_CONNECTION_NAME

שקעי Unix

    docker run -d \
      -v /PATH_TO_HOST_TARGET:/PATH_TO_GUEST_TARGET \
      -v PATH_TO_KEY_FILE:/path/to/service-account-key.json \
      gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.22.1 --unix-socket /cloudsql \
      --credentials-file /path/to/service-account-key.json/PATH_TO_KEY_FILE \
      INSTANCE_CONNECTION_NAME

אם אתם משתמשים בתמונה שעברה אופטימיזציה לקונטיינר, צריך להשתמש בספרייה שאפשר לכתוב בה במקום /cloudsql, למשל:

v /mnt/stateful_partition/cloudsql:/cloudsql

אם אתם משתמשים בפרטי הכניסה שסופקו על ידי מופע Compute Engine, אל תכללו את הפרמטר credential_file ואת השורה -v PATH_TO_KEY_FILE:/path/to/service-account-key.json.

הפעלת שרת proxy ל-Cloud SQL Auth כשירות

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

בשלב הזה, שרת ה-proxy ל-Cloud SQL Auth לא מספק תמיכה מובנית להפעלה כשירות Windows בעומסי עבודה בסביבת ייצור, אבל אפשר להשתמש במנהלי שירותים של צד שלישי כדי להפעיל אותו כשירות. לדוגמה, אפשר להשתמש ב-NSSM כדי להגדיר את Cloud SQL Auth Proxy כשירות Windows, ו-NSSM מנטר את Cloud SQL Auth Proxy ומפעיל אותו מחדש באופן אוטומטי אם הוא מפסיק להגיב. מידע נוסף מופיע במסמכי התיעוד של NSSM.

הערה: אם מריצים את שרת ה-proxy ל-Cloud SQL Auth כשירות, חשוב לזכור שהוא משתמש בחיבור מאובטח כדי לתקשר עם מכונות Cloud SQL, אבל החיבורים מהאפליקציה לשרת ה-proxy ל-Cloud SQL Auth לא מוצפנים. לכן, חשוב לוודא שרק משתמשים מהימנים יכולים לגשת לכתובת ולפורט שבהם שרת ה-proxy ל-Cloud SQL Auth מאזין.

אכיפת השימוש בשרת proxy ל-Cloud SQL Auth

מפעילים את השימוש בשרת proxy ל-Cloud SQL Auth ב-Cloud SQL באמצעות ConnectorEnforcement.

אם אתם משתמשים במופע עם Private Service Connect, יש הגבלה. אם האכיפה של המחבר מופעלת במופע, אי אפשר ליצור רפליקות לקריאה עבור המופע. באופן דומה, אם למופע יש עותקים לקריאה, אי אפשר להפעיל את האכיפה של המחבר במופע.

gcloud

הפקודה הבאה מחייבת שימוש ב-Cloud SQL Connectors.

    gcloud sql instances patch INSTANCE_NAME \
    --connector-enforcement REQUIRED
  

כדי להשבית את האכיפה, משתמשים בשורת הקוד הבאה: --connector-enforcement NOT_REQUIRED העדכון לא מפעיל הפעלה מחדש.

REST v1

הפקודה הבאה מחייבת שימוש ב-Cloud SQL Connectors

לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

• ‫project-id: מזהה הפרויקט.
• ‫instance-id: מזהה המכונה.

ה-method של ה-HTTP וכתובת ה-URL:

PATCH https://sqladmin.googleapis.com/v1/projects/project-id/instances/instance-id

תוכן בקשת JSON:

{
  "settings": {                     
    "connectorEnforcement": "REQUIRED"    
  }                                             
}   

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

‫Curl (Linux,‏ macOS או Cloud Shell)

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login, או באמצעות Cloud Shell שמחבר אתכם אוטומטית ל-CLI של gcloud. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://sqladmin.googleapis.com/v1/projects/project-id/instances/instance-id"

‎PowerShell (Windows)

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method PATCH `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://sqladmin.googleapis.com/v1/projects/project-id/instances/instance-id" | Select-Object -Expand Content

אתם אמורים לקבל תגובת JSON שדומה לזו:

{
  "kind": "sql#operation",
  "targetLink": "https://sqladmin.googleapis.com/v1/projects/project-id/instances/instance-id",
  "status": "PENDING",
  "user": "[e-mail]",
  "insertTime": "2020-01-16T02:32:12.281Z",
  "operationType": "UPDATE",
  "name": "operation-id",
  "targetId": "instance-id",
  "selfLink": "https://sqladmin.googleapis.com/v1/projects/project-id/operations/operation-id",
  "targetProject": "project-id"
}

כדי להשבית את האכיפה, משתמשים במדיניות "connectorEnforcement": "NOT_REQUIRED" במקום זאת. העדכון לא מפעיל הפעלה מחדש.

REST v1beta4

הפקודה הבאה מחייבת שימוש ב-Cloud SQL Connectors.

לפני שמשתמשים בנתוני הבקשה, צריך להחליף את הנתונים הבאים:

• ‫project-id: מזהה הפרויקט.
• ‫instance-id: מזהה המכונה.

ה-method של ה-HTTP וכתובת ה-URL:

PATCH https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/instances/instance-id

תוכן בקשת JSON:

{
  "settings": {
    "connectorEnforcement": "REQUIRED"
  }
}

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

‫Curl (Linux,‏ macOS או Cloud Shell)

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login, או באמצעות Cloud Shell שמחבר אתכם אוטומטית ל-CLI של gcloud. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/instances/instance-id"

‎PowerShell (Windows)

הערה: הפקודה הבאה מבוססת על ההנחה שנכנסתם ל-CLI של gcloud באמצעות חשבון המשתמש שלכם, על ידי הרצת gcloud init או gcloud auth login. כדי לבדוק איזה חשבון פעיל, אפשר להריץ את הפקודה gcloud auth list.

שומרים את גוף הבקשה בקובץ בשם request.json ומריצים את הפקודה הבאה:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method PATCH `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/instances/instance-id" | Select-Object -Expand Content

אתם אמורים לקבל תגובת JSON שדומה לזו:

{
  "kind": "sql#operation",
  "targetLink": "https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/instances/instance-id",
  "status": "PENDING",
  "user": "[e-mail]",
  "insertTime": "2020-01-16T02:32:12.281Z",
  "operationType": "UPDATE",
  "name": "operation-id",
  "targetId": "instance-id",
  "selfLink": "https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/operations/operation-id",
  "targetProject": "project-id"
}

כדי להשבית את האכיפה, משתמשים במדיניות "connectorEnforcement": "NOT_REQUIRED" במקום זאת. העדכון לא מפעיל הפעלה מחדש.

טיפים לעבודה עם שרת proxy ל-Cloud SQL Auth

הפעלת שרת proxy ל-Cloud SQL Auth

כל הקריאות לדוגמה ל-Proxy מתחילות את Cloud SQL Auth Proxy ברקע, ולכן מוחזרת הנחיה. כדאי להשתמש במסוף Cloud Shell הזה רק לשרת proxy ל-Cloud SQL Auth, כדי למנוע ערבוב של הפלט שלו עם הפלט של תוכנות אחרות. בנוסף, הפלט משרת ה-proxy ל-Cloud SQL Auth יכול לעזור לכם לאבחן בעיות בחיבור, ולכן כדאי לתעד אותו בקובץ יומן. אם לא מפעילים את שרת ה-proxy ל-Cloud SQL Auth ברקע, הפלט מועבר ל-stdout אלא אם הוא מנותב מחדש.

לא חייבים להשתמש ב-/cloudsql כספרייה עבור שקעי שרת ה-proxy ל-Cloud SQL Auth. (השם של הספרייה הזו נבחר כדי לצמצם את ההבדלים עם מחרוזות החיבור של App Engine). אם משנים את שם הספרייה, חשוב לשמור על אורך מינימלי כי הוא משולב במחרוזת ארוכה יותר שיש לה מגבלת אורך שמוכתבת על ידי מערכת ההפעלה. האורך המקסימלי תלוי במערכת, אבל בדרך כלל הוא בין 91 ל-108 תווים. ב-Linux, האורך מוגדר בדרך כלל כ-108, ואפשר להשתמש בפקודה הבאה כדי לבדוק:

cat /usr/include/linux/un.h | grep "define UNIX_PATH_MAX"

שימוש בשרת proxy ל-Cloud SQL Auth כדי להתחבר לכמה מכונות

אפשר להשתמש בלקוח מקומי אחד של שרת proxy ל-Cloud SQL Auth כדי להתחבר לכמה מכונות Cloud SQL. הדרך שבה עושים את זה תלויה בשאלה אם משתמשים בשקעי Unix או ב-TCP.

שקעי Unix

כדי לחבר את שרת ה-proxy ל-Cloud SQL Auth לכמה מכונות, צריך לספק את שם החיבור של כל מכונה כארגומנט לשרת ה-proxy ל-Cloud SQL Auth, ברשימה שמופרדת באמצעות רווחים. שרת ה-proxy ל-Cloud SQL Auth מתחבר לכל מופע כשהוא מופעל.

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

לדוגמה:

      ./cloud-sql-proxy --unix-socket /cloudsql \
      myProject:us-central1:myInstance myProject:us-central1:myInstance2 &
      psql -U myUser -h /cloudsql/myProject:us-central1:myInstance2
  

שקעי TCP

כשמתחברים באמצעות TCP, מציינים יציאה במחשב שבה שרת ה-proxy ל-Cloud SQL Auth יאזין לכל מכונה של Cloud SQL. כשמתחברים לכמה מכונות Cloud SQL, כל יציאה שצוינה צריכה להיות ייחודית וזמינה לשימוש במחשב.

לדוגמה:

    # Start the Cloud SQL Auth Proxy to connect to two different Cloud SQL instances
    # Give the Cloud SQL Auth Proxy a unique port on your machine to use for each Cloud SQL instance.

    ./cloud-sql-proxy "myProject:us-central1:myInstance?port=5432" \
    "myProject:us-central1:myInstance2?port=1234"

    # Connect to "myInstance" using port 5432 on your machine:
    psql -U myUser -h 127.0.0.1  --port 5432

    # Connect to "myInstance2" using port 1234 on your machine:
    psql -U myUser -h 127.0.0.1  --port 1234
  

פתרון בעיות בחיבורים של Cloud SQL Auth Proxy

קובץ האימג' של Docker של שרת proxy ל-Cloud SQL Auth מבוסס על גרסה ספציפית של שרת proxy ל-Cloud SQL Auth. כשגרסה חדשה של שרת ה-proxy ל-Cloud SQL Auth זמינה, צריך למשוך את הגרסה החדשה של קובץ אימג' של Docker של שרת ה-proxy ל-Cloud SQL Auth כדי לשמור על סביבה עדכנית. כדי לראות את הגרסה הנוכחית של שרת ה-proxy ל-Cloud SQL Auth, אפשר לעיין ב דף הגרסאות של שרת ה-proxy ל-Cloud SQL Auth ב-GitHub.

אם נתקלתם בבעיות בחיבור למכונת Cloud SQL באמצעות שרת proxy ל-Cloud SQL Auth, הנה כמה דברים שכדאי לנסות כדי לגלות מה גורם לבעיה.

• בודקים את הפלט של שרת ה-Proxy ל-Cloud SQL Auth.

  לרוב, הפלט של שרת ה-Proxy של Cloud SQL Auth יכול לעזור לכם לקבוע את מקור הבעיה ואת הדרך לפתור אותה. מעבירים את הפלט לקובץ או צופים במסוף Cloud Shell שבו הפעלתם את שרת ה-proxy ל-Cloud SQL Auth.

• אם אתם מקבלים שגיאה 403 notAuthorized ואתם משתמשים בחשבון שירות כדי לאמת את שרת ה-proxy ל-Cloud SQL Auth, ודאו שלחשבון השירות יש את ההרשאות הנכונות.

  אפשר לבדוק את חשבון השירות על ידי חיפוש המזהה שלו בדף IAM. צריכה להיות לו ההרשאה cloudsql.instances.connect. התפקידים המוגדרים מראש Cloud SQL Admin,‏ Client ו-Editor כוללים את ההרשאה הזו.

• אם אתם מתחברים מ-App Engine ומוצגת השגיאה 403 notAuthorized, כדאי לבדוק את הערך app.yaml cloud_sql_instances כדי לוודא ששם החיבור של המכונה מאוית נכון. שמות החיבור של המכונות מוצגים תמיד בפורמט PROJECT:REGION:INSTANCE.

  בנוסף, צריך לוודא שלחשבון השירות של App Engine (לדוגמה, ‎$[e-mail]) יש את תפקיד הלקוח של Cloud SQL ב-IAM.

  אם שירות App Engine נמצא בפרויקט אחד (פרויקט א') ומסד הנתונים נמצא בפרויקט אחר (פרויקט ב'), השגיאה הזו מציינת שלחשבון השירות של App Engine לא הוקצה תפקיד Cloud SQL Client IAM בפרויקט עם מסד הנתונים (פרויקט ב').

• חשוב להפעיל את Cloud SQL Admin API.

  אם לא, תראו פלט כמו Error 403: Access Not Configured ביומני שרת ה-proxy ל-Cloud SQL Auth.

• אם אתם כוללים כמה מופעים ברשימת המופעים, הקפידו להשתמש בפסיק כמפריד, ללא רווחים. אם אתם משתמשים ב-TCP, הקפידו לציין יציאות שונות לכל מופע.

• אם אתם מתחברים באמצעות שקעי UNIX, צריך לוודא שהשקעים נוצרו על ידי הצגת רשימת הספרייה שציינתם כשהפעלתם את שרת ה-proxy ל-Cloud SQL Auth.

• אם יש לכם מדיניות חומת אש ליציאה, ודאו שהיא מאפשרת חיבורים ליציאה 3307 במופע היעד של Cloud SQL.

  הערה: שרת ה-proxy ל-Cloud SQL Auth משתמש ביציאה 3307 כדי להתחבר לשרת ה-proxy ל-Cloud SQL Auth. יציאה 5432 היא יציאת ברירת המחדל לפרוטוקול PostgreSQL בחיבור TCP ישיר (לא באמצעות שרת ה-proxy ל-Cloud SQL Auth).

• כדי לוודא ש-Cloud SQL Auth Proxy הופעל בצורה תקינה, אפשר לעיין ביומנים בקטע Operations > Logging > Logs explorer במסוףGoogle Cloud . אם הפעולה בוצעה בהצלחה, הפלט ייראה כך:

  2021/06/14 15:47:56 Listening on /cloudsql/$PROJECT_ID:$REGION:$INSTANCE_NAME/5432 for $PROJECT_ID:$REGION:$INSTANCE_NAME
  2021/06/14 15:47:56 Ready for new connections
  

• בעיות במכסה: אם חורגים מהמכסה של Cloud SQL Admin API, ‏ Cloud SQL Auth Proxy מופעל עם הודעת השגיאה הבאה:

  There was a problem when parsing a instance configuration but ignoring due
  to the configuration. Error: googleapi: Error 429: Quota exceeded for quota
  metric 'Queries' and limit 'Queries per minute per user' of service
  'sqladmin.googleapis.com' for consumer 'project_number:$PROJECT_ID.,
  rateLimitExceeded
  

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

  failed to refresh the ephemeral certificate for $INSTANCE_CONNECTION_NAME:
  googleapi: Error 429: Quota exceeded for quota metric 'Queries' and limit
  'Queries per minute per user' of service 'sqladmin.googleapis.com' for
  consumer 'project_number:$PROJECT_ID., rateLimitExceeded
  

  פתרון: אפשר לזהות את מקור הבעיה במכסה, למשל, אפליקציה שמשתמשת במחבר בצורה לא נכונה ויוצרת חיבורים חדשים שלא לצורך, או לפנות לתמיכה כדי לבקש הגדלה של מכסת Cloud SQL Admin API. אם שגיאת המכסה מופיעה בהפעלה, צריך לפרוס מחדש את האפליקציה כדי להפעיל מחדש את ה-proxy. אם שגיאת המכסה מופיעה אחרי ההפעלה, אין צורך בפריסה מחדש.

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

• מידע נוסף על שרת proxy ל-Cloud SQL Auth
• מידע נוסף על ניהול זהויות והרשאות גישה (IAM)
• מידע נוסף על חשבונות שירות
• שתי רמות בקרת הגישה למכונות Cloud SQL
• יוצרים משתמשים ומסדי נתונים.
• מידע נוסף על התחברות למכונה מהאפליקציה
• מידע על לקוח psql
• מידע על אפשרויות התמיכה