Informazioni sulle opzioni di connessione

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 decidi come connetterti all'istanza Cloud SQL, tieni presente che hai a disposizione molte opzioni, tra cui:

  • Vuoi che l'istanza Cloud SQL sia accessibile da internet, che sia privata all'interno di una rete Virtual Private Cloud (VPC) o che sia accessibile sia pubblicamente che privatamente?
  • Prevedi 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 vengono descritte le opzioni offerte da Cloud SQL per connettersi, autorizzare e autenticarsi al database.

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

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

Prima di iniziare

La concessione dell'accesso a un'applicazione non consente automaticamente a un account utente del database di connettersi all'istanza. Prima di poterti connettere a un'istanza, devi disporre di un account utente del database con cui effettuare la connessione. Per le nuove istanze, devi aver configurato l'account utente predefinito. Per ulteriori informazioni, consulta Gestire gli utenti con l'autenticazione integrata.

Come connettersi a Cloud SQL

Le connessioni al database consumano risorse sul server e sull'applicazione di connessione. Utilizza sempre buone pratiche di gestione delle connessioni per ridurre al minimo l'impronta della tua applicazione e la probabilità di superare i limiti di connessione di Cloud SQL. Per saperne di più, consulta Gestire le connessioni al 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 privati non sono accessibili tramite internet pubblico, ma sono accessibili 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 accessibile su un Virtual Private Cloud (VPC).

Puoi utilizzare questo indirizzo per connetterti da altre risorse con accesso al VPC. Le connessioni tramite IP privato in genere forniscono una latenza inferiore e vettori di attacco limitati perché non richiedono il passaggio attraverso internet. Se vuoi, puoi richiedere che tutte le connessioni utilizzino il proxy Cloud SQL o i certificati SSL con gestione indipendente.

È preferibile configurare l'istanza con un indirizzo IP privato quando ti connetti da un client su una risorsa con accesso a un VPC. Per saperne di più sulle risorse che possono utilizzare l'IP privato, consulta Requisiti per l'IP privato.

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

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

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

Per istruzioni su come aggiungere un indirizzo IP privato all'istanza, consulta una delle seguenti risorse:

IP pubblico

Un IP pubblico è un indirizzo IPv4 disponibile esternamente sulla rete internet pubblica. Questo indirizzo può ricevere connessioni da dispositivi all'interno e all'esterno della rete di Google, ad esempio da luoghi come casa o ufficio.

Per contribuire a mantenere la tua istanza al sicuro, tutte le connessioni a un'istanza Cloud SQL che utilizzano un IP pubblico devono essere autorizzate utilizzando il proxy di autenticazione Cloud SQL o le reti autorizzate.

La configurazione dell'istanza con un indirizzo IP pubblico è consigliata quando ti connetti da un client che non soddisfa i requisiti per un VPC.

Per istruzioni su come aggiungere un IP pubblico all'istanza, consulta Configurare la connettività IP pubblica.

Per informazioni su come connettere un client sqlcmd a un'istanza Cloud SQL tramite IP pubblico, consulta Connessione tramite un client di database.

Come eseguire l'autorizzazione per Cloud SQL

Connettori di lingua Cloud SQL

I connettori dei linguaggi Cloud SQL sono librerie client che forniscono crittografia e autorizzazione IAM quando ti connetti a un'istanza Cloud SQL. Cloud SQL consiglia di utilizzare i connettori dei linguaggi di Cloud SQL per connettersi all'istanza Cloud SQL anziché ad altre opzioni di connessione.

Puoi utilizzare queste librerie direttamente dal linguaggio di programmazione supportato. Forniscono la stessa autenticazione del proxy di autenticazione Cloud SQL senza richiedere un processo esterno. In questo modo, la sicurezza viene migliorata e i requisiti di configurazione per connettersi a Cloud SQL vengono ridotti. Anche i connettori dei linguaggi Cloud SQL utilizzano lo stesso codice quando si connettono utilizzando un indirizzo IP pubblico o privato.

Per iniziare, consulta Informazioni sui connettori di lingua Cloud SQL.

Proxy di autenticazione Cloud SQL

Il proxy di autenticazione Cloud SQL consente di autorizzare e proteggere le connessioni utilizzando le autorizzazioni Identity and Access Management (IAM). Il proxy di autenticazione Cloud SQL convalida le connessioni utilizzando le credenziali di un account utente o di servizio e inserendo la connessione in un livello SSL/TLS autorizzato per un'istanza Cloud SQL. Per ulteriori 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 file binario eseguibile. Il proxy di autenticazione Cloud SQL funge da server intermediario che ascolta le connessioni in entrata, le inserisce in SSL/TLS e poi le passa a un'istanza Cloud SQL.

Alcuni ambienti forniscono un meccanismo che si connette utilizzando il proxy di autenticazione Cloud SQL. Per istruzioni sulla connessione utilizzando questi ambienti, consulta una delle seguenti risorse:

Certificati SSL/TLS autogestiti

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

È vivamente consigliato di utilizzare certificati SSL/TLS con gestione indipendente per fornire la crittografia quando non utilizzi il proxy di autenticazione Cloud SQL. In caso contrario, i tuoi dati vengono trasmessi in modo non sicuro e potrebbero essere intercettati o ispezionati da una terza parte.

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

Reti autorizzate

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

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

Come eseguire l'autenticazione in Cloud SQL

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

Cloud SQL utilizza l'autenticazione integrata del database che si autentica utilizzando un nome utente e una password. Per ulteriori informazioni, consulta la pagina sulla creazione e gestione degli utenti di SQL Server.

Strumenti per la connessione a Cloud SQL

La tabella seguente contiene alcune opzioni per connettersi a Cloud SQL:

Opzione di connessione Ulteriori informazioni
Proxy di autenticazione Cloud SQL
Interfaccia a riga di comando gcloud
Connettori di lingua Cloud SQL
Cloud Shell
Cloud Code
Eseguire la connessione utilizzando strumenti di amministrazione del database di terze parti
SQL Server Management Studio
Esplora oggetti SSMS
Visual Studio

Esempi di codice

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

Connessione con TCP

Istruzione di chiamata del proxy di autenticazione Cloud SQL:

./cloud-sql-proxy INSTANCE_CONNECTION_NAME &

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
}

C#

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

Risoluzione dei problemi

Se hai problemi di connessione, consulta le seguenti pagine per ricevere assistenza per il debugging o per trovare soluzioni a problemi noti:

Passaggi successivi