Cloud SQL-Verbindungen

MySQL   |  PostgreSQL   |  SQL Server

Diese Seite bietet eine Übersicht über die Möglichkeiten, eine Verbindung zu Ihrer Cloud SQL-Instanz herzustellen, und beschreibt die verfügbaren Authentifizierungs- und Autorisierungsoptionen.

Übersicht

Bei der Auswahl einer Verbindung zu Ihrer Cloud SQL-Instanz ist Folgendes zu beachten:

• Möchten Sie, dass Ihre Cloud SQL-Instanz über das Internet zugänglich ist, in einem VPC-Netzwerk (Virtual Private Cloud) privat aufbewahrt wird oder sowohl öffentlich als auch privat darauf zugegriffen werden kann?
• Möchten Sie Ihren eigenen Verbindungscode schreiben oder die Verbindung über öffentlich zugängliche Tools wie den Cloud SQL Auth-Proxy oder einen mysql-Client herstellen?
• Möchten Sie die Verschlüsselung über SSL/TLS erzwingen oder unverschlüsselten Traffic zulassen?

In den folgenden Abschnitten werden die Optionen beschrieben, die Cloud SQL zum Verbinden, Autorisieren und Authentifizieren bei Ihrer Datenbank bietet.

• Verbindungsaufbau: Der Netzwerkpfad, über den Sie Ihre Instanz erreichen:
  • Eine interne, nur über VPC verfügbare (private) IP-Adresse.
  • Eine externe, über das Internet zugängliche (öffentliche) IP-Adresse.
• Authentifizierung: Definiert, welche Verbindungen autorisiert sind und eine Verbindung zu Ihrer Cloud SQL-Instanz herstellen dürfen.
  • Cloud SQL Auth-Proxy und Cloud SQL-Connector-Bibliotheken für Java und Python: Diese bieten Zugriff anhand von IAM.
  • Selbstverwaltete SSL/TLS-Zertifikate: Diese ermöglichen nur Verbindungen mit bestimmten öffentlichen Schlüsseln.
  • Autorisierte Netzwerke: Eine Liste der IP-Adressen, zu denen eine Verbindung hergestellt werden kann.
• Authentifizierung: Die Methode, mit der Sie sich in Ihrer Datenbank anmelden.
  • Integrierte Datenbankauthentifizierung: Anmeldung mit einem im Datenbankmodul festgelegten Nutzernamen/Passwort.

Anhand der folgenden Informationen können Sie entscheiden, welche Verbindungs-, Autorisierungs- und Authentifizierungsoptionen für Sie am besten geeignet sind.

Sie können ein Konto erstellen, um die Leistungsfähigkeit von Cloud SQL in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten in Cloud SQL auszuführen, zu testen und bereitzustellen. Gebühren werden ihnen erst in Rechnung gestellt, wenn sie ein Upgrade ausführen.

Registrieren Sie sich jetzt, um Cloud SQL kostenlos zu testen.

Vorbereitung

Wenn Sie den Zugriff auf eine Anwendung gewähren, wird nicht automatisch ein Datenbanknutzerkonto für die Verbindung mit der Instanz aktiviert. Zum Herstellen einer Verbindung mit einer Instanz benötigen Sie für diese Verbindung ein entsprechendes Datenbanknutzerkonto. Für neue Instanzen bedeutet dies, dass das Standardnutzerkonto konfiguriert sein muss. Weitere Informationen finden Sie unter Nutzer mit integrierter Authentifizierung verwalten.

Verbindung mit Cloud SQL herstellen

Datenbankverbindungen nutzen Ressourcen des Servers und der Anwendung, von der die Verbindung ausgeht. Daher sollten Sie sich bei der Verbindungsverwaltung immer an Best Practices orientieren. So können Sie die Kosten für die Anwendung minimieren und die Wahrscheinlichkeit senken, dass die Verbindungslimits für Cloud SQL überschritten werden. Weitere Informationen finden Sie unter Datenbankverbindungen verwalten.

Öffentliche und private IP-Adressen

In Cloud SQL bedeutet öffentliche IP-Adresse, dass die Instanz über das öffentliche Internet zugänglich ist. Instanzen mit privaten Adressen sind aber nicht über das öffentliche Internet zugänglich, sondern nur über eine Virtual Private Cloud (VPC). Cloud SQL-Instanzen können eine öffentliche und eine private IP-Adresse haben.

Private IP-Adresse

Eine private IP-Adresse ist eine IPv4-Adresse, auf die über die Virtual Private Cloud (VPC) zugegriffen werden kann.

Sie können diese Adresse verwenden, um eine Verbindung von anderen Ressourcen mit Zugriff auf die VPC herzustellen. Verbindungen über private IP-Adressen bieten in der Regel eine geringere Latenz und eingeschränkte Angriffsvektoren, da sie keine Übertragung über das Internet erfordern. Optional können Sie festlegen, dass alle Verbindungen entweder den Cloud SQL-Proxy oder selbstverwaltete SSL-Zertifikate verwenden müssen.

Die Konfiguration Ihrer Instanz mit einer privaten IP-Adresse ist zu bevorzugen, wenn eine Verbindung von einem Client zu einer Ressource mit Zugriff auf eine VPC hergestellt wird. Weitere Informationen dazu, welche Ressourcen private IP-Adressen verwenden können, finden Sie unter Anforderungen für private IP-Adressen.

Bei privaten IP-Pfaden stellen die folgenden Dienste und Anwendungen über den serverlosen VPC-Zugriff direkt eine Verbindung zu Ihrer Instanz her:

• App Engine-Standardumgebung
• Flexible App Engine-Umgebung
• Cloud Run-Funktionen
• Cloud Run

Mehr über die Verwendung einer privaten IP-Adresse mit Cloud SQL erfahren

Eine Anleitung zum Hinzufügen einer privaten IP-Adresse zu Ihrer Instanz finden Sie in einem der folgenden Artikel:

• Private IP-Verbindungen konfigurieren.
• Verbindung zu einer Instanz über Private Service Connect herstellen

Öffentliche IP-Adresse

Eine öffentliche IP-Adresse ist eine IPv4-Adresse, die extern im öffentlichen Internet verfügbar ist. Über diese Adresse können Verbindungen von Geräten innerhalb und außerhalb des Google-Netzwerks hergestellt werden, auch von Standorten wie Ihrem Zuhause oder Ihrem Büro.

Damit Ihre Instanz besser geschützt ist, müssen alle Verbindungen zu einer Cloud SQL-Instanz über eine öffentliche IP-Adresse entweder über den Cloud SQL-Proxy oder über autorisierte Netzwerke autorisiert werden.

Die Konfiguration Ihrer Instanz mit einer öffentlichen IP-Adresse ist am besten, wenn die Verbindung von einem Client aus erfolgt, der die Anforderungen für eine VPC nicht erfüllt.

Hinweise zum Hinzufügen einer öffentlichen IP-Adresse zu Ihrer Instanz finden Sie unter Öffentliche IP-Verbindungen konfigurieren.

Informationen zum Herstellen einer Verbindung eines mysql-Clients zu einer Cloud SQL-Instanz über öffentliche IP-Adressen finden Sie unter Verbindung über einen Datenbankclient herstellen.

Dynamisch zugewiesene IP-Adressen

Einige Anwendungen benötigen für das Herstellen einer Verbindung zur Cloud SQL-Instanz eine dynamisch zugewiesene oder sitzungsspezifische IP-Adresse. Dies ist u. a. bei PaaS-Anwendungen (Platform as a Service) der Fall.

Die beste Lösung für diese Anwendungen ist eine Verbindung über den Cloud SQL Auth-Proxy. Diese Lösung bietet die optimale Zugriffssteuerung für die Instanz.

Verbindungsoptionen für Instanzen

In diesem Abschnitt werden die von Cloud SQL unterstützten Features zum Herstellen einer Verbindung zu Instanzen beschrieben. Der Abschnitt enthält auch unterstützte Verbindungsoptionen zum Erstellen, Deaktivieren und Aktivieren von Instanzen.

Unterstützte Features

In der folgenden Tabelle sind die Funktionen aufgeführt, die Cloud SQL für die Verbindung mit Instanzen über private Verbindungen unterstützt.

Funktion	Instanz mit Zugriff nur auf private Dienste	Nur Instanz mit Private Service Connect	Instanz mit Zugriff auf private Dienste und Private Service Connect
Verbindung von mehreren VPCs herstellen	Nicht unterstützt.	Unterstützt.	Wird über den Private Service Connect-Endpunkt unterstützt.
Externe Replikate	Unterstützt.	Nicht unterstützt.	Unterstützt durch die Verwendung einer ausgehenden Verbindung für den Zugriff auf private Dienste.
Schreibendendenpunkt	Unterstützt.	Nicht unterstützt.	Unterstützt für den Zugriff auf private Dienste.
Verknüpftes VPC-Netzwerk für den Zugriff auf private Dienste ändern	Unterstützt.	Nicht zutreffend.	Nicht unterstützt für den Zugriff auf private Dienste, da für die Instanz Private Service Connect aktiviert ist. Nicht für Private Service Connect.
Sichtbarkeit der Client-IP-Adresse für Cloud SQL	Unterstützt.	Nicht unterstützt.	Wird durch die IP-Adresse für den Zugriff auf private Dienste unterstützt. Wird vom Private Service Connect-Endpunkt nicht unterstützt.

Verbindungsoptionen zum Erstellen von Instanzen

Cloud SQL unterstützt private und öffentliche IP-Konfigurationen. Sie können die Verbindungsoptionen an die Anforderungen Ihrer Anwendung anpassen.

Sie können private IP-Adressen konfigurieren, um Ihre Cloud SQL-Instanzen innerhalb eines VPC-Netzwerk privat zu halten. Die folgenden Arten von privaten Verbindungen werden unterstützt:

• Zugriff auf private Dienste: Verbindung zu Cloud SQL-Instanzen über ein einzelnes VPC-Netzwerk
• Private Service Connect: Sie können eine Verbindung zu Cloud SQL-Instanzen von mehreren VPC-Netzwerken aus herstellen, die zu verschiedenen Gruppen, Teams, Projekten oder Organisationen gehören.

Wenn Ihre Instanz über das öffentliche Internet auf Verbindungen von Clients innerhalb und außerhalb des Google Cloud-Netzwerks zugreifen soll, konfigurieren Sie eine öffentliche IP-Adresse für die Instanz.

Cloud SQL unterstützt die folgenden Verbindungsoptionen zum Erstellen von Instanzen:

• Nur Zugriff auf private Dienste
• Nur Private Service Connect
• Nur öffentliche IP-Adresse
• Sowohl Zugriff auf private Dienste als auch Private Service Connect
• Zugriff auf öffentliche IP-Adressen und private Dienste
• Öffentliche IP-Adresse, Zugriff auf private Dienste und Private Service Connect

Verbindungsoptionen deaktivieren

In Cloud SQL können die folgenden Verbindungsoptionen für Instanzen deaktiviert werden:

• Öffentliche IP-Adresse auf einer Instanz mit Zugriff auf private Dienste und öffentlicher IP-Adresse
• Öffentliche IP-Adresse auf einer Instanz mit öffentlicher IP-Adresse, Zugriff auf private Dienste und Private Service Connect
• Private Service Connect auf einer Instanz mit Private Service Connect und Zugriff auf private Dienste
• Private Service Connect auf einer Instanz mit Private Service Connect, Zugriff auf private Dienste und öffentlicher IP-Adresse

Verbindungsoptionen aktivieren

Cloud SQL unterstützt die Aktivierung der folgenden Verbindungsoptionen für Instanzen:

• Zugriff auf private Dienste auf einer Instanz mit öffentlicher IP-Adresse
• Private Service Connect in einer Instanz mit Zugriff auf private Dienste
• Private Service Connect auf einer Instanz mit Zugriff auf private Dienste und öffentlicher IP-Adresse
• Öffentliche IP-Adresse auf einer Instanz mit Zugriff nur auf private Dienste

Beschränkungen

• Das Erstellen einer Instanz mit öffentlicher IP-Adresse und Private Service Connect wird nicht unterstützt.
• Das Deaktivieren des Zugriffs auf private Dienste auf einer Instanz, die sowohl Zugriff auf private Dienste als auch Private Service Connect bietet, wird nicht unterstützt.
• Das Deaktivieren des Zugriffs auf private Dienste auf einer Instanz, die sowohl den Zugriff auf private Dienste als auch eine öffentliche IP-Adresse hat, wird nicht unterstützt.
• Wenn Sie eine Instanz haben, die nur öffentliche IP-Adressen verwendet, wird die gleichzeitige Aktivierung des Zugriffs auf private Dienste und Private Service Connect nicht unterstützt. Aktivieren Sie zuerst den Zugriff auf private Dienste und dann Private Service Connect.
• IP-basierte Zulassungslisten mithilfe autorisierter Netzwerke werden für Instanzen, für die Private Service Connect aktiviert ist, nicht unterstützt.

Bei Cloud SQL autorisieren

Hinweis: Mit diesen Optionen können Sie nur steuern, welche Verbindungen zu Ihrer Instanz zulässig sind. Zur Authentifizierung beim Datenbankmodul müssen Sie darüber hinaus einen Nutzernamen und ein Passwort für die Datenbank angeben.

Cloud SQL Language Connectors

Cloud SQL Language Connectors sind Bibliotheken, die für das Herstellen einer Verbindung zu einer Cloud SQL-Instanz eine Verschlüsselung sowie eine IAM-Autorisierung ermöglichen. Cloud SQL empfiehlt die Verwendung der Cloud SQL Language Connectors, um über andere Verbindungsoptionen eine Verbindung zur Cloud SQL-Instanz herzustellen.

Sie können diese Bibliotheken direkt in ihrer unterstützten Programmiersprache verwenden. Sie bieten die gleiche Authentifizierung wie der Cloud SQL Auth-Proxy, ohne dass ein externer Prozess erforderlich ist. Dies bietet eine höhere Sicherheit und geringere Konfigurationsanforderungen für die Verbindung mit Cloud SQL. Cloud SQL Language Connectors verwenden beim Herstellen einer Verbindung über eine öffentliche IP-Adresse oder eine private IP-Adresse denselben Code.

Eine Einführung finden Sie unter Cloud SQL Language Connectors.

Cloud SQL Auth-Proxy

Mit dem Cloud SQL Auth-Proxy können Sie Ihre Verbindungen mithilfe von IAM-Berechtigungen (Identity and Access Management) autorisieren und sichern. Der Cloud SQL Auth-Proxy validiert Verbindungen mithilfe von Anmeldedaten für einen Nutzer oder ein Dienstkonto und verpackt die Verbindung in einer SSL/TLS-Ebene, die für eine Cloud SQL-Instanz autorisiert ist. Weitere Informationen über die Funktionsweise des Cloud SQL Auth-Proxys finden Sie unter Informationen zum Cloud SQL Auth-Proxy.

Für die Authentifizierung von Verbindungen zu einer Cloud SQL-Instanz wird die Verwendung des Cloud SQL Auth-Proxys empfohlen, da dies die sicherste Methode ist.

Der Cloud SQL Auth-Proxy ist eine Open-Source-Bibliothek, die als ausführbare Binärdatei verteilt wird. Der Cloud SQL Auth-Proxy dient als Zwischenserver, der eingehende Verbindungen beobachtet, diese in SSL/TLS verpackt und dann an eine Cloud SQL-Instanz weiterleitet.

Einige Umgebungen bieten ein Verfahren, mit dem eine Verbindung über den Cloud SQL Auth-Proxy hergestellt werden kann. Eine Anleitung zum Herstellen einer Verbindung mit diesen Umgebungen finden Sie hier:

• Verbindung von Cloud Run aus herstellen
• Verbindung über Cloud Run-Funktionen herstellen
• Verbindung über die App Engine-Standardumgebung herstellen
• Verbindung über die flexible App Engine-Umgebung herstellen
• Verbindung von Google Kubernetes Engine aus herstellen

Selbstverwaltete SSL/TLS-Zertifikate

Anstatt den Cloud SQL Auth-Proxy zum Verschlüsseln Ihrer Verbindungen zu verwenden, können Sie SSL/TLS-Client-Server-Zertifikate einrichten, die speziell auf eine Cloud SQL-Instanz zugeschnitten sind. Diese Zertifikate werden verwendet, um den Client und den Server gegenseitig zu validieren und Verbindungen zwischen ihnen zu verschlüsseln.

Es wird dringend empfohlen, für die Verschlüsselung selbstverwaltete SSL/TLS-Zertifikate zu verwenden, wenn Sie den Cloud SQL Auth-Proxy nicht nutzen. Andernfalls werden Ihre Daten nicht sicher übertragen und können von Dritten abgefangen oder eingesehen werden.

Informationen zum Einstieg in selbstverwaltete SSL/TLS-Zertifikate finden Sie unter Mit SSL/TLS-Zertifikaten autorisieren.

Autorisierte Netzwerke

Hinweis: Es wird dringend empfohlen, bei der Authentifizierung von Verbindungen immer selbstverwaltete SSL/TLS-Zertifikate zu verwenden. Nur mit Verschlüsselung ist Ihr Traffic vor unbefugtem Zugriff Dritter geschützt.

Sofern nicht der Cloud SQL Auth-Proxy verwendet wird, sind Verbindungen zur öffentlichen IP-Adresse einer Instanz nur zulässig, wenn die Verbindung aus einem autorisierten Netzwerk stammt. Autorisierte Netzwerke sind IP-Adressen oder Bereiche, für die der Nutzer die Verbindungsberechtigung angegeben hat.

Warnung: Seien Sie vorsichtig, wenn Sie autorisierte Netzwerke hinzufügen. Da die Geräte in einem Netzwerk häufig alle die gleiche externe IP-Adresse haben, kann die Autorisierung einer Adresse dazu führen, dass alle Geräte im Netzwerk autorisiert werden und nicht nur ein einzelner Client.

Informationen zum Einstieg in autorisierte Netzwerke finden Sie unter Mit autorisierten Netzwerken autorisieren.

Bei Cloud SQL authentifizieren

Die Authentifizierung ermöglicht eine Zugriffssteuerung, indem die Identität eines Nutzers geprüft wird. Für Endnutzer wird die Authentifizierung ausgeführt, wenn sie ihre Anmeldedaten (einen Nutzernamen und ein Passwort) eingeben. Bei Anwendungen erfolgt die Authentifizierung, wenn die Anmeldedaten eines Nutzers einem Dienstkonto zugewiesen werden.

Cloud SQL verwendet die integrierte Authentifizierung der Datenbank, die sich mit einem Nutzernamen und Passwort authentifiziert. Weitere Informationen finden Sie unter MySQL-Nutzer erstellen und verwalten.

Tools zum Herstellen einer Verbindung zu Cloud SQL

Die folgende Tabelle enthält einige Optionen für die Verbindung zu Cloud SQL:

Verbindungsoption	Weitere Informationen
Cloud SQL Auth-Proxy	Informationen zum Cloud SQL Auth-Proxy Über den Cloud SQL Auth-Proxy verbinden Über das Docker-Image des Cloud SQL Auth-Proxys verbinden
gcloud CLI	gcloud sql connect
Cloud SQL-Sprachverbindungen	Verbindung zu Cloud SQL-Connectors für Java, Python und Go herstellen
Cloud Shell	Verbindung über Cloud Shell herstellen
Apps Script	Externe Verbindungen mit Apps Script GitHub-Beispielseite für Apps Script
Cloud Code	Verbindung über Cloud Code in JetBrains-IDE herstellen
Verbindung mithilfe von Drittanbieter-Datenbankverwaltungstools herstellen
MySQL Workbench	Mit MySQL Workbench verbinden
Toad for MySQL	Mit Toad for MySQL verbinden
SQuirrel SQL	Mit SQuirrel SQL verbinden
phpMyAdmin	phpMyAdmin mit Cloud SQL in App Engine verwenden

Codebeispiele

Sie können eine Verbindung zum Cloud SQL Auth-Proxy mit jeder Sprache herstellen, die eine Verbindung zu Unix- oder TCP-Sockets ermöglicht. Im Folgenden finden Sie einige Code-Snippets aus vollständigen Beispielen auf GitHub, die das Zusammenwirken in der Anwendung veranschaulichen.

Verbindung mit TCP herstellen

Anweisung zum Aufrufen des Cloud SQL Auth-Proxys:

./cloud-sql-proxy INSTANCE_CONNECTION_NAME &

Python

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

import os

import sqlalchemy


def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    """Initializes a TCP connection pool for a Cloud SQL instance of MySQL."""
    # 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. 3306

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # mysql+pymysql://<db_user>:<db_pass>@<db_host>:<db_port>/<db_name>
        sqlalchemy.engine.url.URL.create(
            drivername="mysql+pymysql",
            username=db_user,
            password=db_pass,
            host=db_host,
            port=db_port,
            database=db_name,
        ),
        # ...
    )
    return pool

Java

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

Hinweis:

• INSTANCE_CONNECTION_NAME sollte als <MY-PROJECT>:<INSTANCE-REGION>:<INSTANCE-NAME> dargestellt werden
• Die Verwendung des Arguments ipTypes=PRIVATE erzwingt, dass die SocketFactory eine Verbindung zur zugeordneten privaten IP-Adresse einer Instanz herstellen kann.
• Die Anforderungen für die JDBC Socket Factory-Version der pom.xml-Datei finden Sie hier.

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class TcpConnectionPoolFactory extends ConnectionPoolFactory {

  // Saving credentials in environment variables is convenient, but not secure - consider a more
  // secure solution such as 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();

    // The following URL is equivalent to setting the config options below:
    // jdbc:mysql://<INSTANCE_HOST>:<DB_PORT>/<DB_NAME>?user=<DB_USER>&password=<DB_PASS>
    // 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.setJdbcUrl(String.format("jdbc:mysql://%s:%s/%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "mysql"
    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

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

const mysql = require('promise-mysql');
const fs = require('fs');

// createTcpPool initializes a TCP connection pool for a Cloud SQL
// instance of MySQL.
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 = {
    host: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
    port: process.env.DB_PORT, // e.g. '3306'
    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'
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return mysql.createPool(dbConfig);
};

Go

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

package cloudsql

import (
	"crypto/tls"
	"crypto/x509"
	"database/sql"
	"errors"
	"fmt"
	"log"
	"os"

	"github.com/go-sql-driver/mysql"
)

// connectTCPSocket initializes a TCP connection pool for a Cloud SQL
// instance of MySQL.
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.", 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'
		dbName    = mustGetenv("DB_NAME")       // e.g. 'my-database'
		dbPort    = mustGetenv("DB_PORT")       // e.g. '3306'
		dbTCPHost = mustGetenv("INSTANCE_HOST") // e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
	)

	dbURI := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?parseTime=true",
		dbUser, dbPwd, dbTCPHost, dbPort, dbName)


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

	// ...

	return dbPool, nil
}

C#

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

using MySql.Data.MySqlClient;
using System;

namespace CloudSql
{
    public class MySqlTcp
    {
        public static MySqlConnectionStringBuilder NewMysqlTCPConnectionString()
        {
            // Equivalent connection string:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new MySqlConnectionStringBuilder()
            {
                // 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.
                Server = 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'
                Database = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'

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

        }
    }
}

Ruby

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

tcp: &tcp
  adapter: mysql2
  # 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") { 3306 }%>

PHP

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

namespace Google\Cloud\Samples\CloudSQL\MySQL;

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('mysql:dbname=%s;host=%s', $dbName, $instanceHost);

            // 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/mysql/connect-external-app',
                    $e->getMessage()
                ),
                $e->getCode(),
                $e
            );
        }

        return $conn;
    }
}

Verbindung mit Unix Domain Sockets herstellen

Anweisung zum Aufrufen des Cloud SQL Auth-Proxys:

./cloud-sql-proxy --unix-socket /cloudsql INSTANCE_CONNECTION_NAME &

Python

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

import os

import sqlalchemy


def connect_unix_socket() -> sqlalchemy.engine.base.Engine:
    """Initializes a Unix socket connection pool for a Cloud SQL instance of MySQL."""
    # 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_user = os.environ["DB_USER"]  # e.g. 'my-database-user'
    db_pass = os.environ["DB_PASS"]  # e.g. 'my-database-password'
    db_name = os.environ["DB_NAME"]  # e.g. 'my-database'
    unix_socket_path = os.environ[
        "INSTANCE_UNIX_SOCKET"
    ]  # e.g. '/cloudsql/project:region:instance'

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # mysql+pymysql://<db_user>:<db_pass>@/<db_name>?unix_socket=<socket_path>/<cloud_sql_instance_name>
        sqlalchemy.engine.url.URL.create(
            drivername="mysql+pymysql",
            username=db_user,
            password=db_pass,
            database=db_name,
            query={"unix_socket": unix_socket_path},
        ),
        # ...
    )
    return pool

Java

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class ConnectorConnectionPoolFactory 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 INSTANCE_CONNECTION_NAME =
      System.getenv("INSTANCE_CONNECTION_NAME");
  private static final String INSTANCE_UNIX_SOCKET = System.getenv("INSTANCE_UNIX_SOCKET");
  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");

  public static DataSource createConnectionPool() {
    // The configuration object specifies behaviors for the connection pool.
    HikariConfig config = new HikariConfig();

    // The following URL is equivalent to setting the config options below:
    // jdbc:mysql:///<DB_NAME>?cloudSqlInstance=<INSTANCE_CONNECTION_NAME>&
    // socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=<DB_USER>&password=<DB_PASS>
    // 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.setJdbcUrl(String.format("jdbc:mysql:///%s", DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "mysql"
    config.setPassword(DB_PASS); // e.g. "my-password"

    config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.mysql.SocketFactory");
    config.addDataSourceProperty("cloudSqlInstance", INSTANCE_CONNECTION_NAME);

    // Unix sockets are not natively supported in Java, so it is necessary to use the Cloud SQL
    // Java Connector to connect. When setting INSTANCE_UNIX_SOCKET, the connector will 
    // call an external package that will enable Unix socket connections.
    // Note: For Java users, the Cloud SQL Java Connector can provide authenticated connections
    // which is usually preferable to using the Cloud SQL Proxy with Unix sockets.
    // See https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory for details.
    if (INSTANCE_UNIX_SOCKET != null) {
      config.addDataSourceProperty("unixSocketPath", INSTANCE_UNIX_SOCKET);
    }


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

    // Initialize the connection pool using the configuration object.
    return new HikariDataSource(config);
  }
}

Node.js

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

const mysql = require('promise-mysql');

// createUnixSocketPool initializes a Unix socket connection pool for
// a Cloud SQL instance of MySQL.
const createUnixSocketPool = 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.
  return 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'
    socketPath: process.env.INSTANCE_UNIX_SOCKET, // e.g. '/cloudsql/project:region:instance'
    // Specify additional properties here.
    ...config,
  });
};

C#

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

using MySql.Data.MySqlClient;
using System;

namespace CloudSql
{
    public class MySqlUnix
    {
        public static MySqlConnectionStringBuilder NewMysqlUnixSocketConnectionString()
        {
            // Equivalent connection string:
            // "Server=<INSTANCE_UNIX_SOCKET>;Uid=<DB_USER>;Pwd=<DB_PASS>;Database=<DB_NAME>;Protocol=unix"
            var connectionString = new MySqlConnectionStringBuilder()
            {
                // The Cloud SQL proxy provides encryption between the proxy and instance.
                SslMode = MySqlSslMode.Disabled,

                // 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.
                Server = Environment.GetEnvironmentVariable("INSTANCE_UNIX_SOCKET"), // e.g. '/cloudsql/project:region:instance'
                UserID = Environment.GetEnvironmentVariable("DB_USER"),   // e.g. 'my-db-user
                Password = Environment.GetEnvironmentVariable("DB_PASS"), // e.g. 'my-db-password'
                Database = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'
                ConnectionProtocol = MySqlConnectionProtocol.UnixSocket
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Go

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

package cloudsql

import (
	"database/sql"
	"fmt"
	"log"
	"os"

	_ "github.com/go-sql-driver/mysql"
)

// connectUnixSocket initializes a Unix socket connection pool for
// a Cloud SQL instance of MySQL.
func connectUnixSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Fatal Error in connect_unix.go: %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'
		dbName         = mustGetenv("DB_NAME")              // e.g. 'my-database'
		unixSocketPath = mustGetenv("INSTANCE_UNIX_SOCKET") // e.g. '/cloudsql/project:region:instance'
	)

	dbURI := fmt.Sprintf("%s:%s@unix(%s)/%s?parseTime=true",
		dbUser, dbPwd, unixSocketPath, dbName)

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

	// ...

	return dbPool, nil
}

Ruby

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

unix: &unix
  adapter: mysql2
  # 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" } %>
  # Specify the Unix socket path as host
  socket: "<%= ENV["INSTANCE_UNIX_SOCKET"] %>"

PHP

Wenn Sie dieses Snippet im Kontext einer Webanwendung sehen möchten, rufen Sie die README-Datei auf GitHub auf.

namespace Google\Cloud\Samples\CloudSQL\MySQL;

use PDO;
use PDOException;
use RuntimeException;
use TypeError;

class DatabaseUnix
{
    public static function initUnixDatabaseConnection(): 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'
            $instanceUnixSocket = getenv('INSTANCE_UNIX_SOCKET'); // e.g. '/cloudsql/project:region:instance'

            // Connect using UNIX sockets
            $dsn = sprintf(
                'mysql:dbname=%s;unix_socket=%s',
                $dbName,
                $instanceUnixSocket
            );

            // 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 $instanceUnixSocket (for UNIX socket mode). ' .
                        'The PHP error was %s',
                    $e->getMessage()
                ),
                (int) $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/mysql/connect-external-app',
                    $e->getMessage()
                ),
                (int) $e->getCode(),
                $e
            );
        }

        return $conn;
    }
}

Fehlerbehebung

Wenn beim Herstellen der Verbindung Probleme auftreten, lesen Sie die folgenden Seiten für das Debugging oder zur Suche nach Lösungen für bekannte Probleme:

• Debugging von Verbindungsproblemen
• Bekannte Verbindungsfehler
• Fehlerbehebung bei Cloud SQL Auth-Proxyverbindungen
• Häufige Verbindungsprobleme

Nächste Schritte

• Mithilfe der Kurzanleitung für Cloud SQL for MySQL Verbindungen herstellen
• Best Practices für das Verwalten von Datenbankverbindungen
• Mehr über die IAM-Datenbankauthentifizierung erfahren
• Verbindung über einen mysql-Client von einem lokalen Computer oder von Compute Engine aus herstellen.
• Öffentliche IP-Verbindungen konfigurieren
• Verbindung mithilfe anderer MySQL-Tools herstellen
• MySQL-Connectors
• Informationen zum Cloud SQL Auth-Proxy
• Supportoptionen