Connettiti dalle funzioni di Cloud Run

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

Per istruzioni dettagliate sull'esecuzione di un'applicazione web di esempio delle funzioni 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 ti consente di configurare, gestire e amministrare i database relazionali nel cloud.

Le funzioni di Cloud Run sono una soluzione di computing leggera che consente agli sviluppatori di creare contenuti funzioni autonome che rispondono agli eventi Cloud senza la necessità di gestire un ambiente server o di runtime.

Configura un'istanza Cloud SQL

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

    Enable the API

  2. 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 una nuova istanza. Puoi anche scegliere di assegnare un indirizzo IP privato. Per ulteriori informazioni sulle opzioni di connettività per entrambi, consulta la pagina Panoramica della connessione.

Configurare le funzioni Cloud Run

I passaggi per configurare le funzioni di Cloud Run dipendono dal tipo di Indirizzo IP assegnato all'istanza Cloud SQL.

IP pubblico (predefinito)

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

Per configurare le funzioni Cloud Run in modo da abilitare le connessioni a un'istanza Cloud SQL:
  • Verifica che l'istanza creata sopra abbia un indirizzo IP pubblico. Puoi confermarlo nella pagina Panoramica dell'istanza nella console Google Cloud. Se devi aggiungere un indirizzo IP pubblico, consulta Configurare l'IP pubblico.
  • Ottieni il valore INSTANCE_CONNECTION_NAME dell'istanza. Questo valore è disponibili:
    • Nella pagina Panoramica per l'istanza, nel Console Google Cloud, oppure
    • Eseguendo questo comando: gcloud sql instances describe [INSTANCE_NAME]
  • Configura l'account di servizio per la funzione. Se l'account di servizio di autorizzazione appartiene a un progetto diverso dall'istanza Cloud SQL, abilita l'API Cloud SQL Admin e aggiungi le autorizzazioni IAM elencate di seguito in entrambi i progetti. Verifica che che l'account di servizio abbia Ruoli Cloud SQL e autorizzazioni per la connessione a Cloud SQL.
    • Per connettersi a Cloud SQL, l'account di servizio richiede uno dei seguenti seguo Ruoli IAM:
      • Cloud SQL Client (opzione preferita)
      • Cloud SQL Editor
      • Cloud SQL Admin
      In alternativa, puoi assegnare manualmente le seguenti autorizzazioni IAM:
      • cloudsql.instances.connect
      • cloudsql.instances.get
  • Se utilizzi le funzioni Cloud Run e non le funzioni Cloud Run (1ª gen.), sono obbligatorie le seguenti condizioni (consulta anche Configura Cloud Run):
    1. Esegui inizialmente il deployment della funzione.
      Quando inizi a creare una funzione Cloud Run nella console Google Cloud, il modello di Cloud Run sottostante non è stato ancora creato. Non puoi configurare un la connessione Cloud SQL finché il servizio non viene creato (tramite il deployment la funzione Cloud Run).
    2. Nella console Google Cloud, in alto a destra nella sezione Nella pagina Dettagli funzione, in Basato su Cloud Run, fai clic sull'icona per accedere al servizio Cloud Run sottostante.
    3. Nella pagina Dettagli del servizio di Cloud Run, seleziona la scheda Modifica ed esegui il deployment di una nuova revisione.
    4. Segui le passaggi standard (come nel caso di qualsiasi configurazione modifica) per impostare una nuova configurazione per una connessione Cloud SQL.
      Questo crea una nuova revisione di Cloud Run e revisioni successive automaticamente la connessione Cloud SQL, a meno che la modifica in modo esplicito.

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:

  • In entrambi i progetti, abilita l'API Cloud SQL Admin.
  • Aggiungi le autorizzazioni IAM per l'account di servizio del progetto che contiene l'istanza Cloud SQL.
Un connettore di accesso VPC serverless utilizza indirizzi IP privati per per gestire le comunicazioni con la tua rete VPC. Per connetterti direttamente con indirizzi IP privati, devi eseguire i seguenti passaggi:
  1. Assicurati che l'istanza Cloud SQL creata in precedenza abbia un l'indirizzo IP privato. Se devi aggiungerne uno, consulta Configurare l'IP privato per istruzioni.
  2. Crea un connettore di accesso VPC serverless nello stesso VPC come istanza Cloud SQL. Tieni presente le seguenti condizioni:
    • A meno che non utilizzi VPC condiviso, il connettore deve trovarsi nello stesso progetto e nella stessa regione della risorsa che lo utilizza, ma può inviare traffico a risorse in regioni diverse.
    • L'accesso VPC serverless supporta la comunicazione con le reti VPC connesse tramite Cloud VPN e il peering di reti VPC.
    • L'accesso VPC serverless non supporta le reti legacy.
  3. Configurare le funzioni di Cloud Run per l'utilizzo del connettore.
  4. Connettiti utilizzando l'indirizzo IP privato e la porta 1433 dell'istanza.

Connettiti a Cloud SQL

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

IP pubblico (predefinito)

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

Connettiti con i 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, 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, 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
}

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.

Connettiti con 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, 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 di versione di fabbrica del socket JDBC per 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
}

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. Consulta le guida rapida per l'utilizzo del proxy di autenticazione Cloud SQL per istruzioni dettagliate.

Pool di connessioni

Le connessioni ai database sottostanti potrebbero essere interrotte dal database dal server stesso o dall'infrastruttura sottostante alle funzioni Cloud Run. Me consigliamo di utilizzare una libreria client che supporta i pool di connessioni ricollegano automaticamente le connessioni client interrotte. Inoltre, consigliamo di utilizzare un pool di connessioni con ambito globale per aumentano la probabilità che la funzione riutilizzi la stessa connessione per chiamate successive della funzione e chiude naturalmente la connessione quando l'istanza viene rimossa (scalata automaticamente). Per esempi più dettagliati su come utilizzare i pool di connessioni, consulta Gestire le connessioni al database.

Limiti di connessione

Cloud SQL impone un limite massimo alle connessioni simultanee e questi limiti possono variare a seconda del motore del database scelto (consulta Quote e limiti di Cloud SQL). Ti consigliamo di utilizzare una connessione con le funzioni Cloud Run, ma è importante impostare il numero massimo di connessioni su 1.

Se possibile, devi assicurarti di inizializzare un pool di connessioni solo per le funzioni che devono accedere al tuo database. Alcuni pool di connessioni creeranno connessioni preventive, con un conseguente consumo di risorse in eccesso limiti di connessione. Per questo motivo, ti consigliamo di utilizzare l'inizializzazione lazy per ritardare la creazione di un pool di connessioni fino al momento necessario e di includere il pool di connessioni solo nelle funzioni in cui viene utilizzato.

Per esempi più dettagliati su come limitare il numero di connessioni, consulta Gestire le connessioni al database.

Limiti di quota dell'API

Le funzioni Cloud Run forniscono un meccanismo che si connette utilizzando il proxy di autenticazione Cloud SQL, che utilizza l'API Cloud SQL Admin. I limiti di quota delle 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 per il numero totale di funzioni di cui è stato eseguito il deployment. Puoi imposta il numero massimo di chiamate simultanee per modificare la quota API prevista consumato. Le funzioni Cloud Run impone anche limiti di frequenza sul numero di chiamate API consentite ogni 100 secondi.

Passaggi successivi