Verbindung zu Cloud SQL über App Engine herstellen

Diese Seite enthält Informationen und Beispiele für das Herstellen einer Verbindung zu einer Cloud SQL-Instanz über einen Dienst, der in App Engine ausgeführt wird.

Cloud SQL ist ein vollständig verwalteter Datenbankdienst, mit dem Sie auf einfache Weise Ihre relationalen PostgreSQL- und MySQL-Datenbanken in der Cloud einrichten, warten und verwalten können.

App Engine ist eine vollständig verwaltete, serverlose Plattform für die Entwicklung und das Hosting von Webanwendungen in großem Umfang. Sie können für die Entwicklung Ihrer Anwendungen aus mehreren gängigen Sprachen, Bibliotheken und Frameworks auswählen. App Engine übernimmt dann die Bereitstellung von Servern und die bedarfsgerechte Skalierung Ihrer Anwendungsinstanzen.

Cloud SQL-Instanz einrichten

  1. Cloud SQL for MySQL-Instanz erstellen

  2. Ermitteln Sie auf der Seite Instanzdetails den Wert INSTANCE_CONNECTION_NAME der Instanz. Dafür wird das Format PROJECT_ID:REGION:INSTANCE_ID verwendet. Damit wird die Cloud SQL-Instanz ermittelt, zu der Sie eine Verbindung herstellen.

  3. Aktivieren Sie die Cloud SQL Admin API, falls nicht schon geschehen:

    Aktivieren Sie die API

App Engine konfigurieren

Standard

Für App Engine ist keine spezielle Konfiguration erforderlich. Sie müssen lediglich dafür sorgen, dass das von Ihnen verwendete Dienstkonto die erforderlichen Berechtigungen hat.

Flexibel

Aktualisieren Sie die Datei app.yaml Ihres Projekts mit der Option, die am besten funktioniert. Sie können eine durch Kommas getrennte Liste von Instanzen verwenden, um mehrere Optionen gleichzeitig anzugeben.

Unix Domain Socket aktivieren

Zur Aktivierung eines Unix Domain Sockets fügen Sie der Datei app.yaml Ihres Projekts eine der folgenden Einstellungen hinzu, je nachdem, ob Sie eine Verbindung zu einer oder mehreren Instanzen herstellen möchten:

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

TCP-Port aktivieren

Zur Aktivierung eines lokalen TCP-Ports fügen Sie der Datei app.yaml Ihres Projekts eine der folgenden Einstellungen hinzu, je nachdem, ob Sie eine Verbindung zu einer oder mehreren Instanzen herstellen möchten:

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 verwendet ein Dienstkonto, um Ihre Verbindungen zu Cloud SQL zu autorisieren. Dieses Dienstkonto muss die erforderlichen IAM-Berechtigungen haben, damit eine Verbindung hergestellt werden kann. Sofern nicht anders konfiguriert, hat das Standarddienstkonto das Format service-PROJECT_NUMBER@gae-api-prod.google.com.iam.gserviceaccount.com.

Sie können optional zulassen bzw. unterbinden, dass andere Anwendungen oder Clients eine Verbindung zu Ihrer Cloud SQL-Instanz herstellen. Wie Sie feststellen können, wer eine Verbindung zu Ihrer Instanz herstellen kann und von welchem Ort aus, erfahren Sie unter Authentifizierungsoptionen.

Wenn Sie Ressourcen von zwei verschiedenen Projekten verbinden, müssen für beide Projekte die erforderlichen IAM-Rollen aktiviert und dem Dienstkonto die notwendigen Berechtigungen erteilt worden sein.

Prüfen Sie, ob dem Dienstkonto für Ihren Dienst eine der folgenden IAM-Rollen zugewiesen ist:

  • Cloud SQL Client (bevorzugt)
  • Cloud SQL Editor
  • Cloud SQL Admin

Alternativ können Sie die folgenden IAM-Berechtigungen manuell zuweisen:

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

Eine ausführliche Anleitung zum Hinzufügen von IAM-Rollen zu einem Dienstkonto finden Sie unter Dienstkonten Rollen zuweisen.

Verbindung zu Cloud SQL herstellen

Wenn Cloud Functions korrekt konfiguriert ist, können Sie Ihren Dienst mit dem Unix Domain Socket Ihrer Cloud SQL-Instanz verbinden. Dafür gilt folgendes Format: /cloudsql/INSTANCE_CONNECTION_NAME.

Solche Verbindungen werden ohne zusätzliche Konfiguration automatisch verschlüsselt.

Die unten gezeigten Codebeispiele sind Auszüge aus umfassenderen Beispielen auf der GitHub-Website. Klicken Sie auf View on GitHub, um mehr Code zu sehen. Suchen Sie auf der GitHub-Website nach der README-Datei im selben Verzeichnis wie der Code. In der README-Datei werden wichtige Einrichtungsthemen behandelt, z. B. die Verwendung von Umgebungsvariablen für Anmeldedaten, Verbindungspfade und Datenbankvariablen. Die README-Datei bietet auch Test- und Bereitstellungstipps.

Die flexible App Engine-Umgebung unterstützt auch eine Verbindung über TCP. Wenn für eine Instanz ein TCP-Port festgelegt ist, konfigurieren Sie Ihre Anwendung so, dass stattdessen eine Verbindung zu 172.17.0.1:PORT hergestellt wird.

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.
        # ...
    )
Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie den Quellcode auf GitHub auf.

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);
Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie den Quellcode auf GitHub auf.

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();
Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie den Quellcode auf GitHub auf.

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);
Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie den Quellcode auf GitHub auf.

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"] %>"
Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie den Quellcode auf GitHub auf.

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
Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie den Quellcode auf GitHub auf.

Best Practices und weitere Informationen

Sie können für den lokalen Test Ihrer Anwendung den Cloud SQL-Proxy verwenden. Eine detaillierte Anleitung dazu finden Sie in der Kurzanleitung zur Verwendung des Proxys für lokale Tests.

Verbindungspools

Verbindungen zu den zugrunde liegenden Datenbanken können entweder vom Datenbankserver selbst oder von der zugrunde liegenden Infrastruktur verworfen werden. Um dies zu vermeiden, empfehlen wir die Verwendung einer Clientbibliothek, die Verbindungspools und das automatische Herstellen einer neuen Verbindung unterstützt.

Ausführliche Beispiele zur Verwendung von Verbindungspools finden Sie unter Datenbankverbindungen verwalten.

Verbindungseinschränkungen

Cloud SQL legt ein maximales Limit für gleichzeitige Verbindungen fest. Diese Limits können je nach ausgewähltem Datenbankmodul variieren (siehe Cloud SQL-Kontingente und -Limits).

Wenn die Last zunimmt, erstellt App Engine automatisch mehr Instanzen. Dies kann dazu führen, dass diese Limits überschritten werden. Beschränken Sie die maximale Anzahl an App Engine-Instanzen, um dieses Problems zu vermeiden. Weitere Informationen finden Sie unter Elemente skalieren.

Eine App Engine-Instanz, die in einer Standardumgebung ausgeführt wird, kann maximal 100 Verbindungen gleichzeitig zu einer Instanz herstellen. Bei Anwendungen, die in PHP 5.5 geschrieben sind, ist die Anzahl der gleichzeitigen Verbindungen auf 60 beschränkt.

App Engine-Anwendungen unterliegen je nach Nutzung und Umgebung bestimmten Zeitlimits für Anfragen. Weitere Informationen finden Sie in den Erläuterungen dazu, wie Instanzen in der App Engine-Standardumgebung oder der flexiblen App Engine-Umgebung verwaltet werden.

App Engine-Anwendungen unterliegen außerdem weiteren Kontingenten und Limits von App Engine. Diese werden auf der Seite App Engine-Kontingente dargestellt.