Se connecter à Cloud SQL depuis App Engine

Cette page contient des informations et des exemples de connexion à une instance Cloud SQL à partir d'un service s'exécutant dans App Engine.

Cloud SQL est un service de base de données entièrement géré qui facilite la configuration, la maintenance, la gestion et l'administration de vos bases de données relationnelles PostgreSQL et MySQL dans le cloud.

App Engine est une plate-forme sans serveur entièrement gérée pour le développement et l'hébergement d'applications Web à grande échelle. Vous pouvez choisir parmi plusieurs langages, bibliothèques et frameworks courants pour développer vos applications, puis laisser App Engine se charger du provisionnement des serveurs et du scaling de vos instances d'applications en fonction de la demande.

Configurer une instance Cloud SQL

  1. Créez une instance Cloud SQL pour MySQL.

  2. Recherchez la valeur INSTANCE_CONNECTION_NAME de l'instance sur la page Détails de l'instance. Elle est au format PROJECT_ID:REGION:INSTANCE_ID et permet d'identifier l'instance Cloud SQL à laquelle vous vous connectez.

  3. Activez l'API Cloud SQL Admin, si ce n'est pas déjà fait :

    Activer l'API

Configurer App Engine

Standard

App Engine ne nécessite aucune configuration spéciale, vous devez seulement vous assurer que le compte de service que vous utilisez dispose des autorisations appropriées.

Flexible

Mettez à jour le fichier app.yaml de votre projet avec l'option la plus adaptée. Vous pouvez utiliser une liste d'instances séparées par des virgules pour spécifier plusieurs options à la fois.

Activer un socket de domaine Unix

Pour activer un socket de domaine Unix, ajoutez l'un des éléments suivants dans le fichier app.yaml de votre projet, selon que vous vous connectez à une ou plusieurs instances :

beta_settings:
      cloud_sql_instances: <INSTANCE_CONNECTION_NAME>
    
beta_settings:
      cloud_sql_instances: <INSTANCE_CONNECTION_NAME>,<INSTANCE_CONNECTION_NAME_2>,...
    

Activer un port TCP

Pour activer un port TCP local, ajoutez l'un des éléments suivants dans le fichier app.yaml de votre projet, selon que vous vous connectez à une ou plusieurs instances :

beta_settings:
      cloud_sql_instances: <INSTANCE_CONNECTION_NAME>=tcp:<PORT>
    
beta_settings:
      cloud_sql_instances: <INSTANCE_CONNECTION_NAME>=tcp:<PORT>,<INSTANCE_CONNECTION_NAME_2>=tcp:<PORT>,...
    

App Engine utilise un compte de service pour autoriser vos connexions à Cloud SQL. Ce compte de service doit disposer des autorisations IAM correctes pour que la connexion aboutisse. Sauf indication contraire, le compte de service par défaut est au format service-PROJECT_NUMBER@gae-api-prod.google.com.iam.gserviceaccount.com.

Vous pouvez éventuellement autoriser d'autres applications ou clients à se connecter à votre instance Cloud SQL, ou leur interdire de se connecter. Pour plus d'informations, consultez la section Options d'authentification afin de déterminer qui est autorisé à se connecter à votre instance et à partir d'où.

Lorsque vous connectez des ressources de deux projets différents, assurez-vous que ceux-ci ont activé les rôles IAM corrects et accordé les autorisations appropriées au compte de service.

Vérifiez que le compte de service de votre service dispose de l'un des rôles IAM suivants :

  • Cloud SQL Client (rôle à privilégier)
  • Cloud SQL Editor
  • Cloud SQL Admin

Vous pouvez également attribuer manuellement les autorisations IAM suivantes :

  • cloudsql.instances.connect
  • cloudsql.instances.get

Pour obtenir des instructions détaillées sur l'ajout de rôles IAM à un compte de service, consultez la page Attribuer des rôles aux comptes de service.

Se connecter à Cloud SQL

Une fois votre service correctement configuré, vous pouvez le connecter au socket de domaine Unix de l'instance Cloud SQL en utilisant le format suivant : /cloudsql/INSTANCE_CONNECTION_NAME.

Ces connexions sont automatiquement chiffrées sans configuration supplémentaire.

Les exemples de code présentés ci-dessous sont extraits d'exemples plus complets du site GitHub. Cliquez sur View on GitHub (Afficher sur GitHub) pour plus d'informations. Sur le site GitHub, recherchez le fichier README dans le même répertoire que le code. Le fichier README aborde des sujets de configuration importants, tels que l'utilisation de variables d'environnement pour les identifiants, les chemins de connexion et les variables de base de données. Le fichier README propose également des conseils de test et de déploiement.

L'environnement flexible App Engine est également compatible avec la connexion via TCP. Si vous avez configuré une instance avec un port TCP, configurez votre application pour qu'elle se connecte à 172.17.0.1:PORT à la place.

Python

# The SQLAlchemy engine will help manage interactions, including automatically
    # managing a pool of connections to your database
    db = sqlalchemy.create_engine(
        # Equivalent URL:
        # mysql+pymysql://<db_user>:<db_pass>@/<db_name>?unix_socket=/cloudsql/<cloud_sql_instance_name>
        sqlalchemy.engine.url.URL(
            drivername="mysql+pymysql",
            username=db_user,
            password=db_pass,
            database=db_name,
            query={"unix_socket": "/cloudsql/{}".format(cloud_sql_connection_name)},
        ),
        # ... Specify additional properties here.
        # ...
    )
Pour afficher cet extrait dans le contexte d'une application Web, affichez le code source sur GitHub.

Java

// 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:mysql:///%s", DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "postgres"
    config.setPassword(DB_PASS); // e.g. "my-password"

    // For Java users, the Cloud SQL JDBC Socket Factory can provide authenticated connections.
    // See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.
    config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.mysql.SocketFactory");
    config.addDataSourceProperty("cloudSqlInstance", CLOUD_SQL_CONNECTION_NAME);
    config.addDataSourceProperty("useSSL", "false");

    // ... Specify additional connection properties here.
    // ...

    // Initialize the connection pool using the configuration object.
    DataSource pool = new HikariDataSource(config);
Pour afficher cet extrait dans le contexte d'une application Web, affichez le code source sur GitHub.

Node.js

let pool;
    const createPool = async () => {
      pool = await mysql.createPool({
        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'
        // If connecting via unix domain socket, specify the path
        socketPath: `/cloudsql/${process.env.CLOUD_SQL_CONNECTION_NAME}`,
        // If connecting via TCP, enter the IP and port instead
        // host: 'localhost',
        // port: 3306,

        //...
      });
    };
    createPool();
Pour afficher cet extrait dans le contexte d'une application Web, affichez le code source sur GitHub.

C#

var connectionString = new MySqlConnectionStringBuilder(
        Configuration["CloudSql:ConnectionString"])
    // ConnectionString set in appsetings.json formatted as:
    // "Uid=aspnetuser;Pwd=;Host=cloudsql;Database=votes"
    {
        // Connecting to a local proxy that does not support ssl.
        SslMode = MySqlSslMode.None,
    };
    connectionString.Pooling = true;
    // ...
    DbConnection connection =
        new MySqlConnection(connectionString.ConnectionString);
Pour afficher cet extrait dans le contexte d'une application Web, affichez le code source sur GitHub.

Ruby

development:
      adapter: mysql2
      # ...
      username: <%= ENV["MYSQL_USERNAME"] %>
      password: <%= ENV["MYSQL_PASSWORD"] %>
      database: <%= ENV.fetch("MYSQL_DATABASE") { "vote_development" } %>
      socket:   "/cloudsql/<%= ENV["INSTANCE_CONNECTION_NAME"] %>"
Pour afficher cet extrait dans le contexte d'une application Web, affichez le code source sur GitHub.

Go

var (
    	dbUser                 = mustGetenv("DB_USER")
    	dbPwd                  = mustGetenv("DB_PASS")
    	instanceConnectionName = mustGetenv("INSTANCE_CONNECTION_NAME")
    	dbName                 = mustGetenv("DB_NAME")
    )

    var dbURI string
    dbURI = fmt.Sprintf("%s:%s@unix(/cloudsql/%s)/%s", dbUser, dbPwd, instanceConnectionName, dbName)

    // dbPool is the pool of database connections.
    dbPool, err := sql.Open("mysql", dbURI)
    if err != nil {
    	return nil, fmt.Errorf("sql.Open: %v", err)
    }

    // ...

    return dbPool, nil
Pour afficher cet extrait dans le contexte d'une application Web, affichez le code source sur GitHub.

Bonnes pratiques et autres informations

Vous pouvez utiliser le proxy Cloud SQL lorsque vous testez votre application en local. Pour obtenir des instructions détaillées, consultez le guide de démarrage rapide pour l'exécution de tests en local à l'aide du proxy.

Pools de connexions

Les connexions aux bases de données sous-jacentes peuvent être supprimées, soit par le serveur de base de données lui-même, soit par l'infrastructure sous-jacente. Pour éviter cela, nous vous recommandons d'utiliser une bibliothèque cliente compatible avec les pools de connexions et la reconnexion automatique.

Pour obtenir des exemples plus détaillés d'utilisation des pools de connexions, consultez la page Gérer les connexions à la base de données.

Limites de connexion

Cloud SQL impose une limite maximale de connexions simultanées, laquelle peut varier en fonction du moteur de base de données choisi (consultez la page Quotas et limites de Cloud SQL).

App Engine peut créer automatiquement des instances supplémentaires à mesure que la charge augmente, ce qui peut vous amener à dépasser la limite. Pour éviter ce problème, limitez le nombre maximal d'instances App Engine. Pour plus d'informations, consultez la section Éléments de scaling.

Chaque instance App Engine exécutée dans un environnement standard ne peut pas avoir plus de 100 connexions simultanées à une instance. Pour les applications en PHP 5.5, la limite est de 60 connexions simultanées.

Les applications App Engine sont soumises à des délais de requêtes selon l'utilisation et l'environnement. Pour en savoir plus, découvrez comment les instances sont gérées dans les environnements standard et flexible d'App Engine.

Les applications App Engine sont également soumises à d'autres quotas et limites App Engine, comme indiqué sur la page Quotas d'App Engine.