Connessione da Cloud Run

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 calcolo gestita che ti consente di eseguire container direttamente sull' 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 una località dell'istanza Cloud SQL nella stessa regione del servizio Cloud Run per una latenza migliore, per evitare alcuni costi di rete e per ridurre i rischi di errori tra regioni.

    Per impostazione predefinita, Cloud SQL assegna un indirizzo IP pubblico a una nuova istanza. Hai anche la possibilità 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 indirizzi tutto il traffico in uscita tramite l'uscita VPC diretta o un connettore di accesso VPC serverless, utilizza un indirizzo IP privato. Confronta i due metodi di uscita dalla rete.

IP pubblico (predefinito)

Cloud Run supporta la connessione a Cloud SQL per SQL Server tramite IP pubblico utilizzando i connettori Go, Java e Python.

  • Assicurati che l'istanza abbia un indirizzo IP pubblico. Puoi verificarlo nella pagina Panoramica dell'istanza nella console Google Cloud. Se devi aggiungerne uno, consulta la pagina Configurazione dell'IP pubblico per istruzioni.
  • Ottieni il INSTANCE_CONNECTION_NAME per la tua istanza. Puoi trovare questo valore nella pagina Panoramica della tua istanza nella console Google Cloud o eseguendo il seguente comando gcloud sql instances describe: 
    gcloud sql instances describe INSTANCE_NAME
    Sostituisci INSTANCE_NAME con il nome della tua istanza Cloud SQL.
  • Ottieni l'CLOUD_RUN_SERVICE_ACCOUNT_NAME per il tuo servizio Cloud Run. Puoi trovare questo valore nella pagina IAM del progetto che ospita il servizio Cloud Run nella console Google Cloud o eseguendo il seguente comando gcloud run services describe nel progetto che ospita il servizio Cloud Run: 
    gcloud run services describe CLOUD_RUN_SERVICE_NAME
--region CLOUD_RUN_SERVICE_REGION --format="value(spec.template.spec.serviceAccountName)"
    Sostituisci le seguenti variabili:
    • CLOUD_RUN_SERVICE_NAME: il nome del servizio Cloud Run
    • CLOUD_RUN_SERVICE_REGION: la regione del servizio Cloud Run
  • 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 deve disporre di uno dei seguenti 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
  • Se aggiungi una connessione Cloud SQL a un nuovo servizio, devi avere il servizio in un contenitore e caricato in Container Registry o Artifact Registry. Se non hai già una connessione, consulta queste istruzioni su come creare e implementare un'immagine contenitore.

Come per qualsiasi modifica di configurazione, l'impostazione di una nuova configurazione per la connessione Cloud SQL comporta la creazione di una nuova revisione 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. Per aggiungere connessioni Cloud SQL a un servizio esistente:

    1. Nell'elenco Servizi, fai clic sul nome del servizio che ti interessa.
    2. In Visualizza in Cloud Functions, fai clic sul nome del servizio.
    3. Fai clic su Modifica e ridistribuisci.
  3. Attiva la connessione a un'istanza Cloud SQL:
    1. Fai clic su Container, variabili e secret, connessioni, sicurezza .
    2. Fai clic sulla scheda Contenitore.
    3. Scorri fino a Connessioni Cloud SQL.
    4. Fai clic su Aggiungi connessione.
    5. Fai clic sul pulsante Abilita Cloud SQL Admin se non hai ancora abilitato l'API Cloud SQL Admin.

    Aggiungi una connessione Cloud SQL

    • Se aggiungi una connessione a un'istanza Cloud SQL nel tuo progetto, seleziona l'istanza Cloud SQL che ti interessa dal menu.
    • Se utilizzi un'istanza Cloud SQL di un altro progetto, seleziona stringa di connessione personalizzata nel menu e inserisci il nome completo della connessione dell'istanza nel formato PROJECT-ID:REGION:INSTANCE-ID.
    • Per eliminare un collegamento, tieni premuto il cursore a destra del collegamento per visualizzare l'icona Elimina e fai clic.

  4. Fai clic su Crea o Esegui il deployment.

Riga di comando

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

  • IMAGE con l'immagine di cui stai eseguendo il deployment
  • SERVICE_NAME con il nome del 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.
Le uscite VPC dirette e i connettori utilizzano indirizzi IP privati per gestire la comunicazione con la tua rete VPC. Per connetterti direttamente con indirizzi IP privati utilizzando uno di questi metodi di uscita, procedi nel seguente modo:
  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 di uscita per connetterti alla stessa rete VPC dell'istanza Cloud SQL. Tieni presente le seguenti condizioni:
    • Sia il traffico in uscita VPC diretto sia l'accesso VPC serverless supportano la comunicazione con le reti VPC connesse tramite Cloud VPN e peering di rete VPC.
    • L'uscita VPC diretta e l'accesso VPC serverless non supportano le 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 all'istanza Cloud SQL.

IP pubblico (predefinito)

Per i percorsi IP pubblici, Cloud Run fornisce la crittografia e si connette utilizzando 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, consulta 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
}

Utilizzare 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}-compute@developer.gserviceaccount.com" # 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}-compute@developer.gserviceaccount.com" # 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}-compute@developer.gserviceaccount.com" # 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 all'istanza tramite una rete VPC. Questo metodo utilizza TCP per connettersi direttamente all'istanza Cloud SQL senza utilizzare il proxy di autenticazione Cloud SQL.

Connettiti con 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, consulta 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'utilizzo dell'argomento ipTypes=PRIVATE forza SocketFactory a connettersi all'IP privato associato di 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, consulta 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, consulta 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, consulta 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 il test utilizzando il proxy Cloud SQL tramite un container Docker.

Pool di connessione

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 non attive. Per esempi più dettagliati su come utilizzare i pool di connessioni, consulta la pagina Gestire le connessioni al database.

Limiti di connessione

Sia le versioni MySQL che PostgreSQL di Cloud SQL impongono un limite massimo alle connessioni simultanee e questi limiti possono variare a seconda del motore del database scelto (consulta la pagina Quota 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, in base alla scalabilità, il numero totale di connessioni per deployment può aumentare.

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 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 dell'API Cloud SQL Admin impiegata è circa il doppio del numero di istanze Cloud SQL configurate in base al numero di istanze Cloud Run di un determinato servizio di cui è stato eseguito il deployment in un determinato momento. Puoi limitare o aumentare il numero di istanze Cloud Run per modificare la quota API prevista consumata.

Passaggi successivi