Questa pagina è stata tradotta dall'API Cloud Translation.

Connessione da Cloud Run

MySQL | PostgreSQL | SQL Server

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

Per istruzioni dettagliate sull'esecuzione di un progetto web Cloud Run di esempio connessa a Cloud SQL, osserva guida rapida per la connessione da Cloud Run.

Cloud SQL è un servizio di database completamente gestito che ti consente di configurare, gestire e amministrare i 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

Abilita l'API Cloud SQL Admin nel progetto Google Cloud da cui ti connetti, se non l'hai ancora fatto:

Abilita l'API
Crea un cluster Cloud SQL per un'istanza 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 le 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 verificalo nella pagina Panoramica per la tua istanza nel Console Google Cloud. Se devi aggiungerne una, consulta la Pagina Configurazione IP pubblico per istruzioni.
Ottieni INSTANCE_CONNECTION_NAME per l'istanza. Puoi 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 che l'account di servizio abbia Ruoli Cloud SQL e autorizzazioni per la connessione a Cloud SQL.

Ruoli IAM

Cloud SQL Client (opzione preferita)
Cloud SQL Admin

cloudsql.instances.connect
cloudsql.instances.get

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

Console

Vai a Cloud Run
Inizia a configurare il servizio:
- Se aggiungi una connessione Cloud SQL a un nuovo servizio:
  Devi containerizzare il servizio e caricarlo nel di Container Registry o Artifact Registry. Se non ne hai già uno, scopri questi istruzioni sulla creazione e deployment di nell'immagine container.
- 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.
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 l'amministratore di Cloud SQL se non hai ancora abilitato l'Amministratore Cloud SQL API.
- 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, quindi inserisci il nome completo nome di connessione 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 questa.
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 che stai eseguendo il deployment
SERVICE_NAME con il nome del tuo servizio Cloud Run
INSTANCE_CONNECTION_NAME con il nome di connessione istanza di l'istanza Cloud SQL o un elenco delimitato da virgole nomi delle connessioni.

Se stai eseguendo il deployment di un nuovo container, utilizza il comando seguente:
```
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 container Cloud Run di base con un'istanza Cloud SQL connessa.

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

  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]
}

Applica le modifiche inserendo terraform apply.
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 di autorizzazione appartiene a un progetto diverso da quello una contenente l'istanza Cloud SQL, segui questi passaggi:

Abilita l'API Cloud SQL Admin in entrambi i progetti.
Aggiungi le autorizzazioni IAM per l'account di servizio del 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, procedi nel seguente modo:

Assicurati che l'istanza Cloud SQL creata in precedenza abbia un l'indirizzo IP privato. Per aggiungere un indirizzo IP interno, consulta Configura l'IP privato.
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 un VPC condiviso, un connettore deve condividere lo stesso progetto regione come risorsa che la utilizza, anche se il connettore può inviare traffico alle risorse in diverse regioni.

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 ai connettori Cloud SQL

I connettori Cloud SQL sono librerie specifiche per i linguaggi che forniscono la crittografia e l'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, visualizza il file README su GitHub.

Nota:

CLOUD_SQL_CONNECTION_NAME deve essere rappresentato come <MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME>
Consulta i requisiti di versione di fabbrica del socket JDBC per pom.xml file 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, visualizza 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. Puoi trasmettere i segreti come variabili di ambiente o montare come volume con Cloud Run.

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 conservare in modo sicuro i valori di utente, password e nome del database utilizzando google_secret_manager_secret e google_secret_manager_secret_version. Tieni presente che devi aggiornare l'account di servizio Compute del progetto per avere accesso a ciascun secret.


# 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 per includere i nuovi secret.

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

  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 blocco del 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 a 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 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, visualizza 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 forza l'esecuzione di per la connessione all'IP privato associato a un'istanza
Consulta i requisiti di versione di fabbrica del socket JDBC per pom.xml file 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, visualizza 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 durante il test la tua applicazione in locale. Consulta le guida rapida per l'utilizzo del proxy di autenticazione Cloud SQL per istruzioni dettagliate.

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 database server stesso o dall'infrastruttura della piattaforma. Ti consigliamo di utilizzare una libreria client che supporti i pool di connessioni che riconnettono automaticamente le connessioni client interrotte. Per esempi più dettagliati su come utilizzare i pool di connessioni, consulta Pagina Gestione delle connessioni di 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 di container di Cloud Run sono limitate a 100 connessioni 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 una pool di connessioni. Per esempi più dettagliati su come limitare il numero di connessioni, consulta le Pagina Gestione delle connessioni di database.

Limiti di quota dell'API

Cloud Run fornisce un meccanismo che si connette utilizzando il proxy di autenticazione Cloud SQL, che utilizza 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 delle istanze Cloud Run per modificare la quota API prevista consumato.

Passaggi successivi

Scopri di più su Cloud Run.
Scopri di più su come creare ed eseguire il deployment delle immagini container.