Connessione da Cloud Run

MySQL   |  PostgreSQL   |  SQL Server

Questa pagina contiene informazioni ed esempi per la connessione a un'istanza Cloud SQL da un servizio in esecuzione in Cloud Run.

Per istruzioni dettagliate sull'esecuzione di un'applicazione web di esempio Cloud Run collegata a Cloud SQL, consulta la guida rapida per la connessione da Cloud Run.

Cloud SQL è un servizio di database completamente gestito che semplifica la configurazione, la gestione e l'amministrazione dei database relazionali nel cloud.

Cloud Run è una piattaforma di computing gestita che consente di eseguire i container direttamente dell'infrastruttura Google Cloud.

configura un'istanza Cloud SQL

1. Se non l'hai già fatto, attiva l'API Cloud SQL Admin nel progetto Google Cloud da cui ti connetti:

   Enable the API

2. Crea un'istanza Cloud SQL per SQL Server. Ti consigliamo di scegliere Cloud SQL località dell'istanza nella stessa regione del servizio Cloud Run per migliorare la latenza, evitare alcuni costi di networking e ridurre e rischi di errori tra regioni.

   Per impostazione predefinita, Cloud SQL assegna un indirizzo IP pubblico a un nuovo in esecuzione in un'istanza Compute Engine. Puoi anche scegliere di assegnare un indirizzo IP privato. Per ulteriori informazioni sulle opzioni di connettività per entrambi, consulta la pagina Panoramica della connessione.

Configura Cloud Run

I passaggi per configurare Cloud Run dipendono dal tipo di indirizzo IP assegnato all'istanza Cloud SQL. Se instrada tutto il traffico in uscita attraverso il traffico VPC diretto in uscita o un connettore di accesso VPC serverless, utilizza l'indirizzo IP privato. Confronta i due metodi di traffico in uscita dalla rete.

IP pubblico (predefinito)

Cloud Run supporta la connessione a Cloud SQL per di SQL Server su IP pubblico utilizzando Connettori Go, Java e Python.

• Assicurati che l'istanza creata in precedenza abbia un indirizzo IP pubblico. Puoi verificarlo nella pagina Panoramica della tua istanza nella console Google Cloud. Se devi aggiungerne uno, consulta le Pagina Configurazione IP pubblico per istruzioni.
• Ottieni INSTANCE_CONNECTION_NAME per l'istanza. È possibile trovare nella pagina Panoramica per la tua istanza nel Console Google Cloud o eseguendo seguente comando: gcloud sql instances describe INSTANCE_NAME.
• Configura l'account di servizio per il tuo servizio Cloud Run. Assicurati che l'account di servizio disponga dei ruoli e delle autorizzazioni Cloud SQL appropriati per connettersi a Cloud SQL.
L'account di servizio per il tuo servizio richiede uno dei seguenti requisiti Ruoli IAM:
• Cloud SQL Client (opzione preferita)
• Cloud SQL Admin
In alternativa, puoi assegnare manualmente le seguenti autorizzazioni IAM:
• cloudsql.instances.connect
• cloudsql.instances.get
Nota: Se l'account di servizio di autorizzazione appartiene a un progetto diverso da quello una contenente l'istanza Cloud SQL, devi
• Abilita l'API Cloud SQL Admin in entrambi i progetti.
• Aggiungi le autorizzazioni IAM per l'account di servizio nel progetto contenente l'istanza Cloud SQL.

Come per qualsiasi modifica alla configurazione, l'impostazione di una nuova configurazione connessione Cloud SQL porta alla creazione di un nuovo la revisione di Cloud Run. Anche le revisioni successive acquisiranno automaticamente questa connessione Cloud SQL, a meno che non apporti aggiornamenti espliciti per modificarla.

Console

1. Vai a Cloud Run

2. Inizia a configurare il servizio:

   • Se aggiungi una connessione Cloud SQL a un nuovo servizio:

     Devi avere containerizzato il servizio e caricato su Container Registry o Artifact Registry. Se non ne hai già uno, consulta queste istruzioni su come creare e implementare un'immagine contenitore.

   • Se aggiungi connessioni Cloud SQL a un servizio esistente:
     1. Fai clic sul nome del servizio.
     2. Fai clic sulla scheda Modifica ed esegui il deployment di una nuova revisione.
3. Abilita la connessione a un'istanza Cloud SQL:
   Nota: se la tua applicazione è scritta in Java, puoi saltare questo passaggio poiché esegui questa operazione nella Connettore Cloud SQL.
   1. Fai clic su Container, variabili e secret, connessioni, sicurezza .
   2. Fai clic sulla scheda Contenitore.
   3. Scorri verso il basso fino a Connessioni Cloud SQL.
   4. Fai clic su Aggiungi connessione.
   5. Fai clic sul pulsante Abilita Cloud SQL Admin se non hai ancora attivato l'API Cloud SQL Admin.

   

   • Se aggiungi una connessione a un'istanza Cloud SQL nel tuo progetto, e seleziona l'istanza Cloud SQL che ti interessa dal menu a discesa.
   • Se utilizzi un'istanza Cloud SQL di un altro progetto, seleziona stringa di connessione personalizzata nel menu a discesa e poi inserisci il nome completo della connessione dell'istanza nel formato PROJECT-ID:REGION:INSTANCE-ID.
   • Se stai eliminando una connessione, passa il cursore a destra del connessione per visualizzare l'icona Cestino e fai clic su di essa.

4. Fai clic su Crea o Esegui il deployment.

Riga di comando

Prima di utilizzare uno dei comandi riportati di seguito, effettua le seguenti sostituzioni:

• IMAGE con l'immagine di cui stai eseguendo il deployment
• SERVICE_NAME con il nome del tuo servizio Cloud Run

• INSTANCE_CONNECTION_NAME con il nome di connessione istanza della tua istanza Cloud SQL o un elenco delimitato da virgole di nomi di connessione.

  Se stai eseguendo il deployment di un nuovo contenitore, utilizza il seguente comando:

  gcloud run deploy \
    --image=IMAGE \
    --add-cloudsql-instances=INSTANCE_CONNECTION_NAME

  Se stai aggiornando un servizio esistente, utilizza il seguente comando:

  gcloud run services update SERVICE_NAME \
    --add-cloudsql-instances=INSTANCE_CONNECTION_NAME

Terraform

Il codice seguente crea un contenitore Cloud Run di base con un'istanza Cloud SQL collegata.

resource "google_cloud_run_v2_service" "default" {
  name     = "cloudrun-service"
  location = "us-central1"

  deletion_protection = false # set to "true" in production

  template {
    containers {
      image = "us-docker.pkg.dev/cloudrun/container/hello:latest" # Image to deploy

      volume_mounts {
        name       = "cloudsql"
        mount_path = "/cloudsql"
      }
    }
    volumes {
      name = "cloudsql"
      cloud_sql_instance {
        instances = [google_sql_database_instance.default.connection_name]
      }
    }
  }
  client     = "terraform"
  depends_on = [google_project_service.secretmanager_api, google_project_service.cloudrun_api, google_project_service.sqladmin_api]
}

1. Applica le modifiche inserendo terraform apply.
2. Verifica le modifiche controllando il servizio Cloud Run, facendo clic sulla scheda Revisioni e poi sulla scheda Connessioni.

IP privato

Se l'account di servizio che esegue l'autorizzazione appartiene a un progetto diverso da quello contenente l'istanza Cloud SQL, procedi nel seguente modo:

• In entrambi i progetti, abilita l'API Cloud SQL Admin.
• Aggiungi le autorizzazioni IAM per l'account di servizio nel progetto che contiene l'istanza Cloud SQL.

I connettori e il traffico VPC diretto in uscita utilizzano indirizzi IP privati per gestire la comunicazione con la rete VPC. Per connetterti direttamente con indirizzi IP privati utilizzando uno di questi metodi in uscita, segui questi passaggi:

1. Assicurati che l'istanza Cloud SQL creata in precedenza abbia un indirizzo IP privato. Per aggiungere un indirizzo IP interno, consulta Configurare l'IP privato.
2. Configura il metodo in uscita per connetterti alla stessa rete VPC di Cloud SQL in esecuzione in un'istanza Compute Engine. Tieni presente le seguenti condizioni:
• Il traffico VPC diretto in uscita e l'accesso VPC serverless supportano entrambi comunicazione con reti VPC connesse tramite Cloud VPN e Peering di rete VPC.
• Il traffico VPC diretto in uscita e l'accesso VPC serverless non supportano reti legacy.
• A meno che non utilizzi VPC condiviso, un connettore deve condividere lo stesso progetto e la stessa regione della risorsa che lo utilizza, anche se può inviare traffico alle risorse in regioni diverse.
3. Connettiti utilizzando l'indirizzo IP privato e la porta 1433 dell'istanza.

Connettiti a Cloud SQL

Dopo aver configurato Cloud Run, puoi connetterti di Cloud SQL.

IP pubblico (predefinito)

Per i percorsi IP pubblici, Cloud Run fornisce crittografia e si connette usando i connettori Cloud SQL.

Connettiti con i connettori Cloud SQL

I connettori Cloud SQL sono librerie specifiche per i vari linguaggi che forniscono crittografia e autorizzazione basata su IAM quando ti connetti a un'istanza Cloud SQL.

Python

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

import os

from google.cloud.sql.connector import Connector, IPTypes
import pytds

import sqlalchemy


def connect_with_connector() -> sqlalchemy.engine.base.Engine:
    """
    Initializes a connection pool for a Cloud SQL instance of SQL Server.

    Uses the Cloud SQL Python Connector package.
    """
    # 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_connection_name = os.environ[
        "INSTANCE_CONNECTION_NAME"
    ]  # e.g. 'project:region:instance'
    db_user = os.environ.get("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'

    ip_type = IPTypes.PRIVATE if os.environ.get("PRIVATE_IP") else IPTypes.PUBLIC

    connector = Connector(ip_type)

    connect_args = {}
    # If your SQL Server instance requires SSL, you need to download the CA
    # certificate for your instance and include cafile={path to downloaded
    # certificate} and validate_host=False. This is a workaround for a known issue.
    if os.environ.get("DB_ROOT_CERT"):  # e.g. '/path/to/my/server-ca.pem'
        connect_args = {
            "cafile": os.environ["DB_ROOT_CERT"],
            "validate_host": False,
        }

    def getconn() -> pytds.Connection:
        conn = connector.connect(
            instance_connection_name,
            "pytds",
            user=db_user,
            password=db_pass,
            db=db_name,
            **connect_args
        )
        return conn

    pool = sqlalchemy.create_engine(
        "mssql+pytds://",
        creator=getconn,
        # ...
    )
    return pool

Java

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su GitHub.

Nota:

• CLOUD_SQL_CONNECTION_NAME deve essere rappresentato come <MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME>
• Consulta i requisiti della versione della fabbrica di socket JDBC per il file pom.xml qui .

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 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 is equivalent to setting the config options below:
    // jdbc:sqlserver://;user=<DB_USER>;password=<DB_PASS>;databaseName=<DB_NAME>;
    // socketFactoryClass=com.google.cloud.sql.sqlserver.SocketFactory;
    // socketFactoryConstructorArg=<INSTANCE_CONNECTION_NAME>

    // 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
        .setDataSourceClassName("com.microsoft.sqlserver.jdbc.SQLServerDataSource");
    config.setUsername(DB_USER); // e.g. "root", "sqlserver"
    config.setPassword(DB_PASS); // e.g. "my-password"
    config.addDataSourceProperty("databaseName", DB_NAME);

    config.addDataSourceProperty("socketFactoryClass",
        "com.google.cloud.sql.sqlserver.SocketFactory");
    config.addDataSourceProperty("socketFactoryConstructorArg", INSTANCE_CONNECTION_NAME);

    // The Java Connector provides SSL encryption, so it should be disabled
    // at the driver level.
    config.addDataSourceProperty("encrypt", "false");

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

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

Vai

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su GitHub.

package cloudsql

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

	"cloud.google.com/go/cloudsqlconn"
	mssql "github.com/denisenkom/go-mssqldb"
)

type csqlDialer struct {
	dialer     *cloudsqlconn.Dialer
	connName   string
	usePrivate bool
}

// DialContext adheres to the mssql.Dialer interface.
func (c *csqlDialer) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
	var opts []cloudsqlconn.DialOption
	if c.usePrivate {
		opts = append(opts, cloudsqlconn.WithPrivateIP())
	}
	return c.dialer.Dial(ctx, c.connName, opts...)
}

func connectWithConnector() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Fatal Error in connect_connector.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'
		dbName                 = mustGetenv("DB_NAME")                  // e.g. 'my-database'
		instanceConnectionName = mustGetenv("INSTANCE_CONNECTION_NAME") // e.g. 'project:region:instance'
		usePrivate             = os.Getenv("PRIVATE_IP")
	)

	dbURI := fmt.Sprintf("user id=%s;password=%s;database=%s;", dbUser, dbPwd, dbName)
	c, err := mssql.NewConnector(dbURI)
	if err != nil {
		return nil, fmt.Errorf("mssql.NewConnector: %w", err)
	}
	dialer, err := cloudsqlconn.NewDialer(context.Background())
	if err != nil {
		return nil, fmt.Errorf("cloudsqlconn.NewDailer: %w", err)
	}
	c.Dialer = &csqlDialer{
		dialer:     dialer,
		connName:   instanceConnectionName,
		usePrivate: usePrivate != "",
	}

	dbPool := sql.OpenDB(c)
	if err != nil {
		return nil, fmt.Errorf("sql.Open: %w", err)
	}
	return dbPool, nil
}

Utilizza Secret Manager

Google consiglia di utilizzare Secret Manager per archiviare informazioni sensibili come le credenziali SQL. Con Cloud Run puoi trasmettere i secret come variabili di ambiente o montarli come volume.

Dopo aver creato un secret in Secret Manager, aggiorna un servizio esistente con il seguente comando:

Riga di comando

gcloud run services update SERVICE_NAME \
  --add-cloudsql-instances=INSTANCE_CONNECTION_NAME
  --update-env-vars=INSTANCE_CONNECTION_NAME=INSTANCE_CONNECTION_NAME_SECRET \
  --update-secrets=DB_USER=DB_USER_SECRET:latest \
  --update-secrets=DB_PASS=DB_PASS_SECRET:latest \
  --update-secrets=DB_NAME=DB_NAME_SECRET:latest

Terraform

Di seguito vengono create risorse secret per memorizzare in modo sicuro i valori di nome, password e utente del database utilizzando google_secret_manager_secret e google_secret_manager_secret_version. Tieni presente che devi aggiornare l'account di servizio di calcolo del progetto per avere accesso a ogni segreto.

# Create dbuser secret
resource "google_secret_manager_secret" "dbuser" {
  secret_id = "dbusersecret"
  replication {
    auto {}
  }
  depends_on = [google_project_service.secretmanager_api]
}

# Attaches secret data for dbuser secret
resource "google_secret_manager_secret_version" "dbuser_data" {
  secret      = google_secret_manager_secret.dbuser.id
  secret_data = "secret-data" # Stores secret as a plain txt in state
}

# Update service account for dbuser secret
resource "google_secret_manager_secret_iam_member" "secretaccess_compute_dbuser" {
  secret_id = google_secret_manager_secret.dbuser.id
  role      = "roles/secretmanager.secretAccessor"
  member    = "serviceAccount:${data.google_project.project.number}[e-mail]" # Project's compute service account
}

# Create dbpass secret
resource "google_secret_manager_secret" "dbpass" {
  secret_id = "dbpasssecret"
  replication {
    auto {}
  }
  depends_on = [google_project_service.secretmanager_api]
}

# Attaches secret data for dbpass secret
resource "google_secret_manager_secret_version" "dbpass_data" {
  secret      = google_secret_manager_secret.dbpass.id
  secret_data = "secret-data" # Stores secret as a plain txt in state
}

# Update service account for dbpass secret
resource "google_secret_manager_secret_iam_member" "secretaccess_compute_dbpass" {
  secret_id = google_secret_manager_secret.dbpass.id
  role      = "roles/secretmanager.secretAccessor"
  member    = "serviceAccount:${data.google_project.project.number}[e-mail]" # Project's compute service account
}

# Create dbname secret
resource "google_secret_manager_secret" "dbname" {
  secret_id = "dbnamesecret"
  replication {
    auto {}
  }
  depends_on = [google_project_service.secretmanager_api]
}

# Attaches secret data for dbname secret
resource "google_secret_manager_secret_version" "dbname_data" {
  secret      = google_secret_manager_secret.dbname.id
  secret_data = "secret-data" # Stores secret as a plain txt in state
}

# Update service account for dbname secret
resource "google_secret_manager_secret_iam_member" "secretaccess_compute_dbname" {
  secret_id = google_secret_manager_secret.dbname.id
  role      = "roles/secretmanager.secretAccessor"
  member    = "serviceAccount:${data.google_project.project.number}[e-mail]" # Project's compute service account
}

Aggiorna la risorsa Cloud Run principale in modo da includere i nuovi secret.

resource "google_cloud_run_v2_service" "default" {
  name     = "cloudrun-service"
  location = "us-central1"

  deletion_protection = false # set to "true" in production

  template {
    containers {
      image = "us-docker.pkg.dev/cloudrun/container/hello:latest" # Image to deploy

      # Sets a environment variable for instance connection name
      env {
        name  = "INSTANCE_CONNECTION_NAME"
        value = google_sql_database_instance.default.connection_name
      }
      # Sets a secret environment variable for database user secret
      env {
        name = "DB_USER"
        value_source {
          secret_key_ref {
            secret  = google_secret_manager_secret.dbuser.secret_id # secret name
            version = "latest"                                      # secret version number or 'latest'
          }
        }
      }
      # Sets a secret environment variable for database password secret
      env {
        name = "DB_PASS"
        value_source {
          secret_key_ref {
            secret  = google_secret_manager_secret.dbpass.secret_id # secret name
            version = "latest"                                      # secret version number or 'latest'
          }
        }
      }
      # Sets a secret environment variable for database name secret
      env {
        name = "DB_NAME"
        value_source {
          secret_key_ref {
            secret  = google_secret_manager_secret.dbname.secret_id # secret name
            version = "latest"                                      # secret version number or 'latest'
          }
        }
      }

      volume_mounts {
        name       = "cloudsql"
        mount_path = "/cloudsql"
      }
    }
    volumes {
      name = "cloudsql"
      cloud_sql_instance {
        instances = [google_sql_database_instance.default.connection_name]
      }
    }
  }
  client     = "terraform"
  depends_on = [google_project_service.secretmanager_api, google_project_service.cloudrun_api, google_project_service.sqladmin_api]
}

Applica le modifiche inserendo terraform apply.

Il comando di esempio utilizza la versione del secret latest. Tuttavia, Google consiglia di bloccare il secret a una versione specifica, SECRET_NAME:v1.

IP privato

Per i percorsi IP privati, l'applicazione si connette direttamente attraverso una rete VPC. Questo metodo utilizza TCP per connettersi direttamente all'istanza Cloud SQL senza utilizzare il proxy di autenticazione Cloud SQL.

Connetti tramite TCP

Connettiti utilizzando l'indirizzo IP privato dell'istanza Cloud SQL come host e la porta 1433.

Python

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

import os

import sqlalchemy


def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    """Initializes a TCP connection pool for a Cloud SQL instance of SQL Server."""
    # 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. 1433

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

    return pool

Java

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su GitHub.

Nota:

• CLOUD_SQL_CONNECTION_NAME deve essere rappresentato come <MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME>
• L'uso dell'argomento ipTypes=PRIVATE forzerà l'esecuzione di per la connessione all'IP privato associato a un'istanza
• Consulta i requisiti della versione della fabbrica di socket JDBC per il file pom.xml qui .

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();

    // Configure which instance and what database user to connect with.
    config.setJdbcUrl(
        String.format("jdbc:sqlserver://%s:%s;databaseName=%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "sqlserver"
    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

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su GitHub.

const mssql = require('mssql');

// createTcpPool initializes a TCP connection pool for a Cloud SQL
// instance of SQL Server.
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 = {
    server: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
    port: parseInt(process.env.DB_PORT), // e.g. 1433
    user: process.env.DB_USER, // e.g. 'my-db-user'
    password: process.env.DB_PASS, // e.g. 'my-db-password'
    database: process.env.DB_NAME, // e.g. 'my-database'
    options: {
      trustServerCertificate: true,
    },
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return mssql.connect(dbConfig);
};

Vai

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

package cloudsql

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

	_ "github.com/denisenkom/go-mssqldb"
)

// connectTCPSocket initializes a TCP connection pool for a Cloud SQL
// instance of SQL Server.
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.\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'
		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. '1433'
		dbName    = mustGetenv("DB_NAME")       // e.g. 'my-database'
	)

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


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

	// ...

	return dbPool, nil
}

Ruby

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

tcp: &tcp
  adapter: sqlserver
  # 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") { 1433 }%> 

PHP

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

namespace Google\Cloud\Samples\CloudSQL\SQLServer;

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(
                'sqlsrv:server=%s;Database=%s',
                $instanceHost,
                $dbName
            );

            // 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/sqlserver/connect-external-app',
                    $e->getMessage()
                ),
                (int) $e->getCode(),
                $e
            );
        }

        return $conn;
    }
}

Best practice e altre informazioni

Puoi utilizzare il proxy di autenticazione Cloud SQL per testare la tua applicazione localmente. Per istruzioni dettagliate, consulta la guida rapida per l'utilizzo del proxy di autenticazione Cloud SQL.

Puoi anche eseguire dei test utilizzando Proxy Cloud SQL tramite un container Docker.

Pool di connessioni

Le connessioni ai database sottostanti potrebbero essere interrotte dal server database stesso o dall'infrastruttura della piattaforma. Ti consigliamo di utilizzare una libreria client che supporti i pool di connessioni che ricollegano automaticamente le connessioni client interrotte. Per esempi più dettagliati su come utilizzare i pool di connessioni, consulta la pagina Gestire le connessioni al database.

Limiti di connessione

Entrambe le versioni MySQL e PostgreSQL di Cloud SQL impongono un limite massimo connessioni simultanee e questi limiti possono variare a seconda del database motore scelto (vedi Quote e limiti di Cloud SQL).

Le istanze dei contenitori Cloud Run hanno un limite di 100 connessioni a un database Cloud SQL. Ogni istanza di un servizio o job Cloud Run può avere 100 connessioni al database e, man mano che il servizio o il job viene scalato, il numero totale di connessioni per deployment possono crescere.

Puoi limitare il numero massimo di connessioni utilizzate per istanza utilizzando un pool di connessioni. Per esempi più dettagliati su come limitare il numero di connessioni, consulta la pagina Gestire le connessioni al database.

Limiti di quota dell'API

Cloud Run fornisce un meccanismo che si connette utilizzando il proxy di autenticazione Cloud SQL, che utilizza l'API Cloud SQL Admin. I limiti di quota dell'API si applicano al proxy di autenticazione Cloud SQL. La quota per l'API Cloud SQL Admin è circa il doppio del numero di istanze Cloud SQL e configurate in base al numero di istanze Cloud Run di una determinata contemporaneamente. Puoi limitare o aumentare il numero di istanze Cloud Run per modificare la quota API prevista consumata.

Passaggi successivi

• Scopri di più su Cloud Run.
• Scopri di più su come creare e implementare le immagini container.