Connettiti dall'ambiente standard di App Engine

Questa pagina contiene informazioni ed esempi per la connessione a un un'istanza Cloud SQL da un servizio in esecuzione nell'ambiente standard App Engine.

Cloud SQL è un servizio di database completamente gestito che semplifica la configurazione, la gestione e l'amministrazione dei database relazionali nel cloud.

App Engine è una piattaforma serverless completamente gestita sviluppare e ospitare applicazioni web su larga scala. Puoi scegliere tra diversi linguaggi, librerie e framework di uso comune per sviluppare le tue app, poi lasciare che sia App Engine a occuparsi del provisioning dei server e della scalabilità delle istanze di app in base alla domanda.

configura un'istanza Cloud SQL

  1. Se non l'hai già fatto, attiva l'API Cloud SQL Admin nel progetto Google Cloud da cui ti connetti:

    Enable the API

  2. Crea un cluster Cloud SQL per MySQL. Ti consigliamo di scegliere Cloud SQL località dell'istanza nella stessa regione del servizio Cloud Run per migliorare la latenza, evitare alcuni costi di networking e ridurre e rischi di errori tra regioni.

    Per impostazione predefinita, Cloud SQL assegna un indirizzo IP pubblico a un nuovo in esecuzione in un'istanza Compute Engine. Hai anche la possibilità di assegnare un indirizzo IP privato. Per ulteriori informazioni sulle opzioni di connettività per entrambi, consulta la pagina Panoramica della connessione.

Configura l'ambiente standard di App Engine

I passaggi per configurare l'ambiente standard di App Engine dipendono dal tipo di indirizzo IP assegnato all'istanza Cloud SQL.

IP pubblico (predefinito)

Per configurare l'ambiente standard di App Engine in modo da abilitare le connessioni a un'istanza Cloud SQL utilizzando l'IP pubblico:

  • Assicurati che l'istanza creata sopra abbia un indirizzo IP pubblico. Puoi verificarlo nella pagina Panoramica della tua istanza nella console Google Cloud. Se hai bisogno di aggiungerne uno, consulta la pagina Configurazione dell'IP pubblico per istruzioni.
  • Ottieni INSTANCE_CONNECTION_NAME per l'istanza. Puoi trovarlo nella pagina Panoramica della tua istanza nella console Google Cloud o eseguendo il seguente comando: gcloud sql instances describe [INSTANCE_NAME].
  • Assicurati che l'account di servizio utilizzato dalla tua app per autenticare le chiamate Cloud SQL dispone della Ruolo Cloud SQL e autorizzazioni.
    • L'account di servizio per il tuo servizio richiede uno dei seguenti requisiti Ruoli IAM:
      • Cloud SQL Client (opzione preferita)
      • Cloud SQL Editor
      • Cloud SQL Admin
      In alternativa, puoi assegnare manualmente le seguenti autorizzazioni IAM:
      • cloudsql.instances.connect
      • cloudsql.instances.get
      Per istruzioni dettagliate sull'aggiunta di ruoli IAM a un account di servizio, consulta Concessione di ruoli agli account di servizio.

    Per impostazione predefinita, l'app autorizzerà le connessioni utilizzando un Account di servizio App Engine. L'identità dell'account di servizio è nel formato PROJECT_ID@appspot.gserviceaccount.com.

    Se l'account di servizio che concede l'autorizzazione appartiene a un progetto diverso dall'istanza Cloud SQL, sarà necessario aggiungere le autorizzazioni IAM e l'API di amministrazione Cloud SQL per entrambi i progetti.

IP privato

Se l'account di servizio che esegue l'autorizzazione appartiene a un progetto diverso da quello contenente l'istanza Cloud SQL, procedi nel seguente modo:

  • In entrambi i progetti, abilita l'API Cloud SQL Admin.
  • Aggiungi le autorizzazioni IAM per l'account di servizio del progetto che contiene l'istanza Cloud SQL.
Un connettore di accesso VPC serverless utilizza indirizzi IP privati per per gestire le comunicazioni con la tua rete VPC. Per connetterti direttamente con indirizzi IP privati, devi eseguire i seguenti passaggi:
  1. Assicurati che l'istanza Cloud SQL creata in precedenza abbia un indirizzo IP privato. Se devi aggiungerne uno, consulta Configurare l'IP privato per istruzioni.
  2. Crea un connettore di accesso VPC serverless nello stesso VPC come istanza Cloud SQL. Tieni presente le seguenti condizioni:
    • A meno che non utilizzi VPC condiviso, il connettore deve trovarsi nello stesso progetto regione come risorsa che la utilizza, ma può inviare traffico alle risorse regioni diverse.
    • L'accesso VPC serverless supporta la comunicazione Reti VPC connesse tramite Cloud VPN e Peering di rete VPC.
    • Accesso VPC serverless non supporta le reti legacy.
  3. Configura l'ambiente standard di App Engine per l'utilizzo del connettore.
  4. Connettiti utilizzando l'indirizzo IP privato e la porta 3306 dell'istanza.

Connettiti a Cloud SQL

Dopo aver configurato l'ambiente standard App Engine, puoi connetterti all'istanza Cloud SQL.

IP pubblico (predefinito)

Per i percorsi IP pubblici, l'ambiente standard di App Engine fornisce la crittografia e si connette utilizzando il proxy di autenticazione Cloud SQL in due modi:

IP privato

Per i percorsi IP privati, l'applicazione si connette direttamente attraverso una rete VPC. Questo metodo utilizza TCP per connettersi direttamente all'istanza Cloud SQL senza utilizzare il proxy di autenticazione Cloud SQL.

Connettiti con TCP

Connettiti utilizzando l'indirizzo IP privato dell'istanza Cloud SQL come host e porta 3306.

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 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

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

Nota:

  • INSTANCE_CONNECTION_NAME deve essere rappresentata come &lt;MY-PROJECT&gt;:&lt;INSTANCE-REGION&gt;:&lt;INSTANCE-NAME&gt;
  • L'uso dell'argomento ipTypes=PRIVATE forzerà l'esecuzione di per la connessione all'IP privato associato a un'istanza
  • Consulta i requisiti di versione di fabbrica del socket JDBC per pom.xml qui . 


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

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

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

Vai

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

package cloudsql

import (
	"crypto/tls"
	"crypto/x509"
	"database/sql"
	"errors"
	"fmt"
	"io/ioutil"
	"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#

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su GitHub.

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

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su GitHub.

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

Per visualizzare questo snippet nel contesto di un'applicazione web, consulta il file README su GitHub.

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

Best practice e altre informazioni

Puoi utilizzare il proxy di autenticazione Cloud SQL per testare la tua applicazione localmente. Consulta le guida rapida per l'utilizzo del proxy di autenticazione Cloud SQL per istruzioni dettagliate.

Pool di connessione

Le connessioni ai database sottostanti potrebbero essere interrotte dal server del database stesso o dall'infrastruttura sottostante. Per ovviare a questo problema, ti consigliamo di utilizzare una libreria client che supporti pool di connessioni e la riconnessione automatica.

Limiti di connessione

Ogni istanza App Engine in esecuzione in un ambiente standard non può avere più di 100 connessioni simultanee a un'istanza. Per Per le app PHP 5.5, il limite è di 60 connessioni simultanee. Questo limite si applica per istanza di applicazione. Ciò significa che ogni istanza L'applicazione App Engine può avere così tante connessioni al database, e, man mano che scala, il numero totale di connessioni per deployment può crescere. Per ulteriori informazioni, consulta Eseguire la scalabilità degli elementi.

Puoi limitare il numero massimo di connessioni utilizzate per istanza utilizzando un pool di connessioni. Per esempi più dettagliati su come limitare il numero di connessioni, consulta la pagina Gestire le connessioni al database.

Le applicazioni App Engine sono soggette a limiti temporali di richiesta a seconda dell'uso e dell'ambiente. Per ulteriori informazioni, scopri come vengono gestite le istanze nell'ambiente standard di App Engine standard e in quello flessibile di App Engine.

Limiti di quota API

App Engine fornisce un meccanismo che si connette utilizzando il proxy di autenticazione Cloud SQL, che utilizza l'API Cloud SQL Admin. I limiti di quota delle API si applicano al proxy di autenticazione Cloud SQL. Quando l'API Cloud SQL Admin viene avviata, utilizza una quota di due e in seguito una media di due ogni ora. La La quota predefinita è di 180 al minuto per utente. Le applicazioni App Engine soggetti a quote e limiti aggiuntivi, come illustrato in alla pagina Quote di App Engine.