Présentation de la connexion

Cette page présente les différentes manières de se connecter à l'instance Cloud SQL et décrit les options d'authentification et d'autorisation disponibles.

Présentation

Lorsque vous envisagez de vous connecter à votre instance Cloud SQL, vous devez tenir compte de nombreux éléments, tels que :

  • Souhaitez-vous que votre instance Cloud SQL soit accessible depuis Internet ou reste privée dans un réseau de cloud privé virtuel (VPC), ou qu'elle soit accessible à la fois publiquement et de manière privée ?
  • Comptez-vous écrire votre propre code de connexion ou vous connecter à l'aide d'outils accessibles publiquement, comme par exemple le proxy d'authentification Cloud SQL ou un client sqlcmd ?
  • Voulez-vous imposer le chiffrement via SSL/TLS ou autoriser le trafic non chiffré ?

Les sections suivantes présentent les options fournies par Cloud SQL pour se connecter, autoriser et s'authentifier auprès de votre base de données.

  • Comment se connecter : chemin réseau à utiliser pour atteindre votre instance :
    • Une adresse IP interne uniquement, VPC uniquement (privée).
    • Une adresse IP externe et accessible à Internet (publique).
  • Comment s'authentifier : connexions autorisées vous permettant de vous connecter à votre instance Cloud SQL :
    • Les bibliothèques de connecteurs Cloud SQL et de proxy d'authentification Cloud SQL pour Java et Python, qui fournissent un accès basé sur IAM.
    • Certificats SSL/TLS autogérés : ils n'autorisent que les connexions basées sur des clés publiques spécifiques.
    • Réseaux autorisés : liste des adresses IP autorisées à se connecter.
  • Comment s'authentifier : méthode de connexion à votre base de données.
    • Authentification intégrée à la base de données : connectez-vous à l'aide d'un nom d'utilisateur/mot de passe défini dans le moteur de base de données.

Utilisez les informations qui suivent pour déterminer les options de connexion, d'autorisation et d'authentification qui répondent le mieux à vos besoins.

Avant de commencer

Le fait d'accorder l'accès à une application ne permet pas automatiquement à un compte utilisateur de base de données de se connecter à l'instance. Pour pouvoir vous connecter à cette dernière, vous devez disposer d'un compte utilisateur de base de données permettant d'établir la connexion. Pour les nouvelles instances, cela signifie que vous devez avoir configuré le compte utilisateur par défaut. En savoir plus

Options de connexion

Les connexions aux bases de données consomment des ressources sur le serveur et sur l'application de connexion. Suivez toujours les bonnes pratiques en matière de gestion des connexions afin de réduire au maximum l'encombrement de votre application et les risques de dépassement des limites de connexion Cloud SQL. Pour en savoir plus, consultez la page Gérer les connexions à la base de données.

Adresse IP privée

Une adresse IP privée est une adresse IPv4 ou IPv6 qui est accessible sur un cloud privé virtuel (VPC, Virtual Private Cloud).

Vous pouvez utiliser cette adresse pour vous connecter à partir d'autres ressources ayant accès au VPC. Les connexions via une adresse IP privée offrent généralement une latence plus faible et des vecteurs d'attaque limités, car leur transit par Internet n'est pas nécessaire. Si vous le souhaitez, vous pouvez exiger que toutes les connexions utilisent le proxy Cloud SQL ou les certificats SSL autogérés.

Lorsque la connexion s'effectue à partir d'un client sur une ressource ayant accès à un réseau VPC, il est préférable d'utiliser une adresse IP privée. Pour en savoir plus sur les ressources pouvant utiliser une adresse IP privée, consultez la page Conditions requises pour utiliser une adresse IP privée.

Pour les chemins d'accès des adresses IP privées, les services et applications suivants se connectent directement à votre instance via l'accès au VPC sans serveur :

  • Environnement standard App Engine
  • Environnement flexible App Engine
  • Cloud Functions
  • Cloud Run

Découvrez comment utiliser une adresse IP privée avec Cloud SQL.

Pour obtenir des instructions sur l'ajout d'une adresse IP privée à votre instance, consultez la section Configurer la connectivité IP privée.

Adresse IP publique

Une adresse IP publique est une adresse IPv4 ou IPv6 qui est accessible en externe sur l'Internet public. Cette adresse peut recevoir des connexions provenant d'appareils internes et externes au réseau Google, y compris depuis votre domicile ou votre bureau.

Pour sécuriser votre instance, les connexions à une instance Cloud SQL utilisant une adresse IP publique doivent être autorisées via le proxy d'authentification Cloud SQL ou les réseaux autorisés.

La configuration d'une instance avec une adresse IP publique est préférable lorsque vous vous connectez depuis un client qui ne répond pas aux exigences d'un VPC.

Pour savoir comment ajouter une adresse IP publique à votre instance, consultez la page Configurer la connectivité IP publique.

Pour en savoir plus sur la connexion d'un client sqlcmd à une instance Cloud SQL à l'aide d'une adresse IP publique, consultez la page Se connecter à l'aide d'un client de base de données.

Options d'autorisation

Proxy d'authentification Cloud SQL

Le proxy d'authentification Cloud SQL vous permet d'authentifier et de sécuriser vos connexions à l'aide des autorisations IAM (Identity and Access Management). Le proxy d'authentification Cloud SQL valide les connexions en utilisant les identifiants d'un utilisateur ou d'un compte de service et en encapsulant la connexion dans une couche SSL/TLS qui est autorisée pour une instance Cloud SQL. Pour en savoir plus sur le fonctionnement du proxy d'authentification Cloud SQL, consultez la page À propos du proxy d'authentification Cloud SQL.

L'utilisation du proxy d'authentification Cloud SQL est recommandée pour l'authentification des connexions à une instance Cloud SQL, car il s'agit de la méthode la plus sécurisée.

Le proxy d'authentification Cloud SQL est une bibliothèque Open Source distribuée en tant que binaire exécutable. Le proxy d'authentification Cloud SQL agit comme un serveur intermédiaire qui écoute les connexions entrantes, les encapsule en SSL/TLS, puis les transmet à une instance Cloud SQL.

Certains environnements fournissent un mécanisme de connexion à l'aide du proxy d'authentification Cloud SQL. Pour savoir comment vous connecter à l'aide de ces environnements, consultez l'une des pages suivantes :

Bibliothèques de connecteurs Cloud SQL pour Java et Python

Cloud SQL propose des bibliothèques clientes qui fournissent des fonctionnalités de chiffrement et d'autorisation IAM lors de la connexion à une instance Cloud SQL à l'aide de connecteurs Java et Python.

Vous pouvez utiliser ces bibliothèques directement à partir de l'environnement du langage. Elles fournissent la même authentification que le proxy d'authentification Cloud SQL, sans processus externe. Pour faire vos premiers pas, consultez la page Se connecter à l'aide de connecteurs Cloud SQL.

Certificats SSL/TLS autogérés

Au lieu d'utiliser le proxy d'authentification Cloud SQL pour chiffrer vos connexions, il est possible de configurer des certificats SSL/TLS client/serveur spécifiques à une instance Cloud SQL. Ces certificats permettent à la fois de valider le client/serveur et de chiffrer les connexions entre eux.

Il est fortement recommandé d'utiliser des certificats SSL/TLS autogérés pour assurer le chiffrement lorsque vous n'utilisez pas le proxy d'authentification Cloud SQL. À défaut, vos données sont transmises de manière non sécurisée, et peuvent être interceptées ou inspectées par un tiers.

Pour commencer à utiliser les certificats SSL/TLS autogérés, consultez la section Autoriser avec des certificats SSL/TLS.

Réseaux autorisés

À moins d'utiliser le proxy d'authentification Cloud SQL, les connexions à l'adresse IP publique d'une instance ne sont autorisées que si elles proviennent d'un réseau autorisé. Les réseaux autorisés sont des adresses IP ou des plages spécifiées par l'utilisateur auxquelles il est possible de se connecter.

Pour commencer à utiliser les réseaux autorisés, consultez la page Autoriser avec des réseaux autorisés.

Options d'authentification

L'authentification permet de contrôler les accès en validant l'identité d'un utilisateur. Pour les utilisateurs finaux, l'authentification est réalisée lorsque l'utilisateur saisit des identifiants (un nom d'utilisateur et un mot de passe). Pour les applications, l'authentification est effectuée lorsque les identifiants d'un utilisateur sont attribués à un compte de service.

Cloud SQL utilise l'authentification intégrée à la base de données qui authentifie à l'aide d'un nom d'utilisateur et d'un mot de passe. Pour plus d'informations, consultez la section Créer et gérer des utilisateurs SQL Server.

Outils de connexion

Le tableau suivant contient des options permettant de se connecter à Cloud SQL :

Option de connexion En savoir plus
Proxy d'authentification Cloud SQL
gcloud
Connecteurs de langage Cloud SQL
Cloud Shell
Se connecter à l'aide d'outils d'administration de bases de données tiers
SQL Server Management Studio
SMSS Object Explorer
Visual Studio

Exemples de code

Vous pouvez vous connecter au proxy d'authentification Cloud SQL au moyen de n'importe quel langage permettant la connexion à un socket TCP. Vous trouverez ci-dessous des extraits de code tirés d'exemples complets disponibles sur GitHub pour vous aider à comprendre comment ils fonctionnent ensemble dans votre application.

Se connecter avec TCP

Instruction d'appel du proxy d'authentification Cloud SQL :

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

Python

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur GitHub.

# Remember - storing secrets in plaintext is potentially unsafe. Consider using
# something like https://cloud.google.com/secret-manager/docs/overview to help keep
# secrets secret.
db_user = os.environ["DB_USER"]
db_pass = os.environ["DB_PASS"]
db_name = os.environ["DB_NAME"]
db_host = os.environ["DB_HOST"]

# Extract host and port from environment variable DB_HOST
host_args = db_host.split(":")
db_hostname, db_port = host_args[0], int(host_args[1])

# SQL Server drivers don't account for this
if db_hostname == "localhost":
    db_hostname = "127.0.0.1"

# The SQLAlchemy engine will help manage interactions, including automatically
# managing a pool of connections to your database
pool = sqlalchemy.create_engine(
    # Equivalent URL:
    # mssql+pytds://<db_user>:<db_pass>@/<host>:<port>/<db_name>?driver=ODBC+Driver+17+for+SQL+Server
    sqlalchemy.engine.url.URL.create(
        "mssql+pytds",
        username=db_user,
        password=db_pass,
        database=db_name,
        host=db_hostname,
        port=db_port,
    ),
    **db_config
)

Java

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur GitHub.

Remarque :

  • CLOUD_SQL_CONNECTION_NAME doit être représenté sous la forme <MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME>.
  • L'utilisation de l'argument ipTypes=PRIVATE force la connexion de SocketFactory à l'adresse IP privée associée à une instance.
  • Pour en savoir plus sur les exigences de version Socket Factory des sockets JDBC pour le fichier pom.xml, cliquez ici.

// Note: For Java users, the Cloud SQL JDBC Socket Factory can provide authenticated connections
// which is preferred to using the Cloud SQL Proxy with Unix sockets.
// See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.

// 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);

// ... Specify additional connection properties here.

// ...

// Initialize the connection pool using the configuration object.
DataSource pool = new HikariDataSource(config);

Node.js

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur GitHub.

const createPool = async () => {
  const config = {pool: {}, options: {}};
  config.user = process.env.DB_USER; // e.g. 'my-db-user'
  config.password = process.env.DB_PASS; // e.g. 'my-db-password'
  config.database = process.env.DB_NAME; // e.g. 'my-database'
  // set the server to '172.17.0.1' when connecting from App Engine Flex
  config.server = process.env.DEPLOYED ? '172.17.0.1' : '127.0.0.1';
  config.port = 1433;

  // ...
  config.options.trustServerCertificate = true;
  return await mssql.connect(config);
};

Go

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur GitHub.

var (
	dbUser    = mustGetenv("DB_USER") // e.g. 'my-db-user'
	dbPwd     = mustGetenv("DB_PASS") // e.g. 'my-db-password'
	dbTCPHost = mustGetenv("DB_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("mssql", dbURI)
if err != nil {
	return nil, fmt.Errorf("sql.Open: %v", err)
}

// ...

return dbPool, nil

C#

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur GitHub.

            // Equivalent connection string:
            // "User Id=<DB_USER>;Password=<DB_PASS>;Server=<DB_HOST>;Database=<DB_NAME>;"
            var connectionString = new SqlConnectionStringBuilder()
            {
                // Remember - storing secrets in plain text is potentially unsafe. Consider using
                // something like https://cloud.google.com/secret-manager/docs/overview to help keep
                // secrets secret.
                DataSource = Environment.GetEnvironmentVariable("DB_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;
            // ...
            return connectionString;

Ruby

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur GitHub.

development:
  adapter: sqlserver
  # Configure additional properties here.
  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("DB_HOST") { "127.0.0.1" }%> # '172.17.0.1' if deployed to GAE Flex
  port: <%= ENV.fetch("DB_PORT") { 1433 }%> 

PHP

Pour afficher cet extrait dans le contexte d'une application Web, consultez le fichier README sur GitHub.

// $username = 'your_db_user';
// $password = 'yoursupersecretpassword';
// $dbName = 'your_db_name';
// $dbHost = "127.0.0.1";

// Connect using TCP
$dsn = sprintf('sqlsrv:server=%s;Database=%s', $dbHost, $dbName);

// Connect to the database
$conn = new PDO($dsn, $username, $password, $connConfig);

Dépannage

Si vous rencontrez des problèmes de connexion, consultez les pages suivantes pour obtenir des conseils de débogage ou de recherche de solutions à des problèmes connus :

Étape suivante