Informazioni sulle opzioni di connessione

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questa pagina fornisce una panoramica dei modi in cui puoi connetterti all'istanza Cloud SQL e descrive le opzioni di autenticazione e autorizzazione disponibili.

Panoramica

Quando scegli come connetterti alla tua istanza Cloud SQL, devi tenere a mente molte scelte, tra cui:

  • Vuoi che l'istanza Cloud SQL sia accessibile da Internet o che rimanga privata all'interno di una rete Virtual Private Cloud (VPC) oppure che sia accessibile pubblicamente e privatamente?
  • Stai pianificando di scrivere il tuo codice di connessione o di connetterti utilizzando strumenti disponibili pubblicamente come il proxy di autenticazione Cloud SQL o un client sqlcmd?
  • Vuoi richiedere la crittografia tramite SSL/TLS o consentire il traffico non criptato?

Nelle sezioni seguenti, illustreremo le opzioni offerte da Cloud SQL per connettersi, autorizzare e autenticare il database.

  • Come connettersi: il percorso di rete che utilizzi per raggiungere l'istanza:
    • Un indirizzo IP interno solo per VPC (privato).
    • Un indirizzo IP esterno accessibile tramite Internet (pubblico).
  • Come autorizzare: quali connessioni sono autorizzate e autorizzate a connettersi all'istanza Cloud SQL:
    • Proxy di autenticazione Cloud SQL e librerie connettore Cloud SQL per Java e Python, che forniscono l'accesso in base a IAM.
    • Certificati SSL/TLS autogestiti: consentono solo le connessioni basate su chiavi pubbliche specifiche.
    • Reti autorizzate: un elenco di indirizzi IP autorizzati a connettersi.
  • Come eseguire l'autenticazione: il metodo di accesso al database.
    • Autenticazione database integrata: accedi con un nome utente o una password impostati nel motore del database.

Utilizza le informazioni riportate di seguito per scegliere le opzioni di connessione, autorizzazione e autenticazione più adatte alle tue esigenze.

Prima di iniziare

La concessione dell'accesso a un'applicazione non consente automaticamente a un account utente di database di connettersi all'istanza. Prima di poterti connettere a un'istanza, devi avere un account utente di database con cui puoi connetterti. Per le nuove istanze, questo significa che devi aver configurato l'account utente predefinito. Scopri di più.

Opzioni di connessione

Le connessioni di database consumano risorse sul server e sull'applicazione di connessione. Utilizza sempre buone pratiche di gestione delle connessioni per ridurre al minimo l'impatto della tua applicazione e ridurre la probabilità di superare i limiti di connessione di Cloud SQL. Per ulteriori informazioni, consulta Gestione delle connessioni ai database.

IP pubblico e privato

In Cloud SQL, l'IP pubblico indica che l'istanza è accessibile tramite la rete Internet pubblica. Al contrario, le istanze che utilizzano solo IP privato non sono accessibili tramite la rete Internet pubblica, ma lo sono tramite un virtual private cloud (VPC). Le istanze Cloud SQL possono avere un indirizzo IP pubblico e uno privato.

IP privato

Un IP privato è un indirizzo IPv4 a cui è possibile accedere su un Virtual Private Cloud (VPC).

Puoi utilizzarlo per connetterti da altre risorse con accesso al VPC. Le connessioni su IP privato in genere forniscono latenza più bassa e vettori di attacco limitati perché non richiedono l'attraversamento di Internet. Facoltativamente, puoi richiedere che tutte le connessioni utilizzino il proxy Cloud SQL o i certificati SSL autogestiti.

La configurazione dell'istanza con un IP privato è preferibile quando si esegue la connessione da un client su una risorsa con accesso a un VPC. Per ulteriori informazioni sulle risorse che possono utilizzare l'IP privato, consulta i requisiti per l'IP privato.

Per i percorsi IP privati, i servizi e le applicazioni seguenti si connettono direttamente alla tua istanza tramite l'accesso VPC serverless:

  • Ambiente standard di App Engine
  • Ambiente flessibile di App Engine
  • Cloud Functions
  • Cloud Run

Scopri di più sull'utilizzo dell'IP privato con Cloud SQL

Per istruzioni su come aggiungere un IP privato all'istanza, consulta Configurazione della connettività con IP privato.

IP pubblico

Un IP pubblico è un indirizzo IPv4 disponibile esternamente sulla rete Internet pubblica. Questo indirizzo può ricevere connessioni da dispositivi sia all'interno sia all'esterno della rete di Google, anche da posizioni come la casa o l'ufficio.

Per proteggere la tua istanza, qualsiasi connessione a un'istanza Cloud SQL che utilizza un IP pubblico deve essere autorizzata utilizzando il proxy di autenticazione Cloud SQL o le reti autorizzate.

La configurazione dell'istanza con un IP pubblico è la soluzione migliore quando si esegue la connessione da un client che non soddisfa i requisiti di un VPC.

Per istruzioni sull'aggiunta di un IP pubblico alla tua istanza, consulta Configurazione della connettività IP pubblica.

Per informazioni sulla connessione di un client sqlcmd a un'istanza Cloud SQL tramite IP pubblico, consulta Connessione tramite un client di database.

Opzioni di autorizzazione

Proxy di autenticazione Cloud SQL

Il proxy di autenticazione Cloud SQL ti consente di autorizzare e proteggere le tue connessioni utilizzando le autorizzazioni di Identity and Access Management (IAM). Il proxy di autenticazione Cloud SQL convalida le connessioni utilizzando le credenziali per un account utente o di servizio e completando la connessione in un livello SSL/TLS autorizzato per un'istanza Cloud SQL. Per maggiori dettagli sul funzionamento del proxy di autenticazione Cloud SQL, consulta Informazioni sul proxy di autenticazione Cloud SQL.

L'utilizzo del proxy di autenticazione Cloud SQL è il metodo consigliato per autenticare le connessioni a un'istanza Cloud SQL perché è il metodo più sicuro.

Il proxy di autenticazione Cloud SQL è una libreria open source distribuita come programma binario di esecuzione. Il proxy di autenticazione Cloud SQL funge da server intermedio che ascolta le connessioni in entrata, le aggrega in SSL/TLS e poi le trasferisce a un'istanza di Cloud SQL.

Alcuni ambienti forniscono un meccanismo che si connette utilizzando il proxy di autenticazione Cloud SQL. Per istruzioni sulla connessione tramite questi ambienti, consulta uno dei seguenti articoli:

Librerie del connettore Cloud SQL per Java e Python

Cloud SQL offre librerie client che forniscono crittografia e autorizzazione basata su IAM quando si connettono a un'istanza Cloud SQL utilizzando connettori Java e Python.

Puoi utilizzare queste librerie direttamente dall'ambiente linguistico. Forniscono la stessa autenticazione del proxy Cloud Auth di Cloud SQL senza richiedere un processo esterno. Per iniziare, consulta Stabilire la connessione utilizzando i connettori Cloud SQL.

Certificati SSL/TLS autogestiti

Anziché utilizzare il proxy di autenticazione Cloud SQL per criptare le tue connessioni, è possibile configurare certificati SSL/TLS client/server specifici per un'istanza Cloud SQL. Questi certificati vengono utilizzati per convalidare il client e il server e per criptare le connessioni tra loro.

Consigliamo vivamente di utilizzare i certificati SSL/TLS autogestiti per fornire la crittografia quando non utilizzi il proxy di autenticazione Cloud SQL. In caso contrario, i tuoi dati verranno trasmessi in modo non sicuro e potrebbero essere intercettati o ispezionati da terze parti.

Per iniziare a utilizzare i certificati SSL/TLS autogestiti, consulta Autorizzazione con i certificati SSL/TLS.

Reti autorizzate

A meno che non utilizzi il proxy di autenticazione Cloud SQL, le connessioni all'indirizzo IP pubblico di un'istanza sono consentite solo se la connessione proviene da una rete autorizzata. Le reti autorizzate sono indirizzi o intervalli IP che l'utente ha specificato come autorizzati a connettersi.

Per iniziare a utilizzare le reti autorizzate, consulta la pagina Autorizzazione con reti autorizzate.

Opzioni di autenticazione

L'autenticazione fornisce il controllo dell'accesso verificando l'identità di un utente. Per gli utenti finali, l'autenticazione viene ottenuta quando l'utente inserisce le credenziali (nome utente e password). Per le applicazioni, l'autenticazione si ottiene quando le credenziali di un utente sono assegnate a un account di servizio.

Cloud SQL utilizza l'autenticazione integrata del database che autentica utilizzando un nome utente e una password. Per ulteriori informazioni, consulta la sezione Creare e gestire utenti SQL Server.

Strumenti per la connessione

La tabella seguente contiene alcune opzioni per la connessione a Cloud SQL:

Opzione di connessione Informazioni dettagliate
Proxy di autenticazione Cloud SQL
gcloud.
Connettori di linguaggio Cloud SQL
Cloud Shell
Connettiti utilizzando strumenti di amministrazione di database di terze parti
Studio SQL Server Management
SMS Object Explorer
Visual Studio

Esempi di codice

Puoi connetterti al proxy di autenticazione Cloud SQL da qualsiasi linguaggio che ti permetta di connetterti a un socket TCP. Di seguito sono riportati alcuni snippet di codice da esempi completi su GitHub per aiutarti a comprendere come interagiscono insieme nella tua applicazione.

Connessione con TCP

Dichiarazione di chiamata proxy Cloud SQL Auth:

./cloud_sql_proxy -instances=INSTANCE_CONNECTION_NAME=tcp:1433 &

Python

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

import os

import sqlalchemy

# connect_tcp_socket initializes a TCP connection pool
# for a Cloud SQL instance of SQL Server.
def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    # 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 vedere questo snippet nel contesto di un'applicazione web, consulta il file README su GitHub.

Note:

  • CLOUD_SQL_CONNECTION_NAME deve essere rappresentata come <MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME>
  • L'uso dell'argomento ipTypes=PRIVATE impone a SocketFactory di connettersi con un IP privato associato a un'istanza
  • Consulta i requisiti di versione di fabbrica del 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 vedere 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);
};

Go

Per vedere 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("Warning: %s environment variable not set.", k)
		}
		return v
	}
	// Note: Saving credentials in environment variables is convenient, but not
	// secure - consider a more secure solution such as
	// Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
	// keep secrets safe.
	var (
		dbUser    = mustGetenv("DB_USER")       // e.g. 'my-db-user'
		dbPwd     = mustGetenv("DB_PASS")       // e.g. 'my-db-password'
		dbTCPHost = mustGetenv("INSTANCE_HOST") // e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
		dbPort    = mustGetenv("DB_PORT")       // e.g. '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: %v", err)
	}

	// ...

	return dbPool, nil
}

C#

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

using Microsoft.Data.SqlClient;
using System;

namespace CloudSql
{
    public class SqlServerTcp
    {
        public static SqlConnectionStringBuilder NewSqlServerTCPConnectionString()
        {
            // Equivalent connection string:
            // "User Id=<DB_USER>;Password=<DB_PASS>;Server=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new SqlConnectionStringBuilder()
            {
                // 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.
                DataSource = Environment.GetEnvironmentVariable("INSTANCE_HOST"), // e.g. '127.0.0.1'
                // Set Host to 'cloudsql' when deploying to App Engine Flexible environment
                UserID = Environment.GetEnvironmentVariable("DB_USER"),         // e.g. 'my-db-user'
                Password = Environment.GetEnvironmentVariable("DB_PASS"),       // e.g. 'my-db-password'
                InitialCatalog = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'

                // The Cloud SQL proxy provides encryption between the proxy and instance
                Encrypt = false,
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Ruby

Per vedere 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 vedere 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;
    }
}

Risolvere i problemi

Se hai problemi di connessione, consulta le seguenti pagine per assistenza su come eseguire il debug o trovare soluzioni a problemi noti:

Passaggi successivi