Gestione delle connessioni ai database

Questa pagina fornisce best practice ed esempi di codice specifici per i vari linguaggi per aiutarti a creare applicazioni che utilizzano le connessioni ai database Cloud SQL in modo efficace.

Questi esempi sono estratti di un'applicazione App Engine completa a tua disposizione su GitHub. Scopri di più.

Pool di connessione

Un pool di connessioni è una cache di connessioni al database che vengono condivise e riutilizzate per migliorare la latenza e le prestazioni della connessione. Quando l'applicazione ha bisogno di una connessione al database, ne prende in prestito temporaneamente una dal pool; al termine dell'applicazione, la connessione restituisce la connessione al pool, dove può essere riutilizzata alla successiva applicazione della connessione al database.

Aprire e chiudere le connessioni

Quando utilizzi un pool di connessioni, devi aprire e chiudere correttamente le connessioni, in modo che queste vengano sempre restituite al pool quando hai terminato. Le connessioni non restituite o "con perdite di dati" non vengono riutilizzate, il che spreca risorse e può causare colli di bottiglia delle prestazioni per la tua applicazione.

Python

cloud-sql/sql-server/sqlalchemy/app.py 
# Preparing a statement before hand can help protect against injections.
stmt = sqlalchemy.text(
    "INSERT INTO votes (time_cast, candidate) VALUES (:time_cast, :candidate)"
)
try:
    # Using a with statement ensures that the connection is always released
    # back into the pool at the end of statement (even if an error occurs)
    with db.connect() as conn:
        conn.execute(stmt, time_cast=time_cast, candidate=team)
except Exception as e:
    # If something goes wrong, handle the error in this section. This might
    # involve retrying or adjusting parameters depending on the situation.
    # ...

Java

cloud-sql/sqlserver/servlet/src/main/java/com/example/cloudsql/IndexServlet.java 
// Using a try-with-resources statement ensures that the connection is always released back
// into the pool at the end of the statement (even if an error occurs)
try (Connection conn = pool.getConnection()) {

  // PreparedStatements can be more efficient and project against injections.
  PreparedStatement voteStmt = conn.prepareStatement(
      "INSERT INTO votes (time_cast, candidate) VALUES (?, ?);");
  voteStmt.setTimestamp(1, now);
  voteStmt.setString(2, team);

  // Finally, execute the statement. If it fails, an error will be thrown.
  voteStmt.execute();

} catch (SQLException ex) {
  // If something goes wrong, handle the error in this section. This might involve retrying or
  // adjusting parameters depending on the situation.
  // ...
}

Node.js

cloud-sql/sqlserver/mssql/index.js 
try {
  const stmt =
    'INSERT INTO votes (time_cast, candidate) VALUES (@timestamp, @team)';
  // Using a prepared statement protects against SQL injection attacks.
  // When prepare is called, a single connection is acquired from the connection pool
  // and all subsequent executions are executed exclusively on this connection.
  const ps = new mssql.PreparedStatement(pool);
  ps.input('timestamp', mssql.DateTime);
  ps.input('team', mssql.VarChar(6));
  await ps.prepare(stmt);
  await ps.execute({
    timestamp: timestamp,
    team: team,
  });
  await ps.unprepare();
} catch (err) {
  // If something goes wrong, handle the error in this section. This might
  // involve retrying or adjusting parameters depending on the situation.
  // ...
}

C#

cloud-sql/sql-server/ConnectTcp.cs 
using Microsoft.Data.SqlClient;
using System;

namespace CloudSql
{
    public class SqlServerTcp
    {
        public static SqlConnectionStringBuilder NewSqlServerTCPConnectionString()
        {
            // Equivalent connection string:
            // "User Id=<DB_USER>;Password=<DB_PASS>;Server=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new SqlConnectionStringBuilder()
            {
                // 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.
                DataSource = 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'
                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;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Go

cloudsql/sqlserver/database-sql/cloudsql.go 
insertVote := "INSERT INTO votes (candidate, created_at) VALUES (@TEAM, GETDATE())"
_, err := db.Exec(insertVote, sql.Named("TEAM", team))

Ruby

cloud-sql/sqlserver/activerecord/app/controllers/votes_controller.rb 
@vote = Vote.new candidate: candidate

# ActiveRecord creates and executes your SQL and automatically
# handles the opening and closing of the database connection.
if @vote.save
  render json: "Vote successfully cast for \"#{@vote.candidate}\" at #{@vote.time_cast} PST!"
else
  render json: @vote.errors, status: :unprocessable_entity
end

PHP

cloud_sql/sqlserver/pdo/src/Votas.php 
// Use prepared statements to guard against SQL injection.
$sql = 'INSERT INTO votes (time_cast, candidate) VALUES (GETDATE(), :voteValue)';

try {
    $statement = $conn->prepare($sql);
    $statement->bindParam('voteValue', $value);

    $res = $statement->execute();
} catch (PDOException $e) {
    throw new RuntimeException(
        'Could not insert vote into database. The PDO exception was ' .
        $e->getMessage(),
        $e->getCode(),
        $e
    );
}

Conteggio connessioni

Ogni connessione al database utilizza risorse client e lato server. Inoltre, Cloud SQL impone limiti di connessione complessivi che non possono essere superati. La creazione e l'utilizzo di un minor numero di connessioni riduce i costi generali e ti aiuta a rimanere al di sotto del limite di connessioni.

Python

cloud-sql/sql-server/sqlalchemy/connect_tcp.py 
# Pool size is the maximum number of permanent connections to keep.
pool_size=5,
# Temporarily exceeds the set pool_size if no connections are available.
max_overflow=2,
# The total number of concurrent connections for your application will be
# a total of pool_size and max_overflow.

Java

cloud-sql/sqlserver/servlet/src/main/java/com/example/cloudsql/ConnectionPoolFactory.java 
// maximumPoolSize limits the total number of concurrent connections this pool will keep. Ideal
// values for this setting are highly variable on app design, infrastructure, and database.
config.setMaximumPoolSize(5);
// minimumIdle is the minimum number of idle connections Hikari maintains in the pool.
// Additional connections will be established to meet this value unless the pool is full.
config.setMinimumIdle(5);

Node.js

cloud-sql/sqlserver/mssql/index.js 
  // 'max' limits the total number of concurrent connections this pool will keep. Ideal
  // values for this setting are highly variable on app design, infrastructure, and database.
  (config.pool.max = 5);
// 'min' is the minimum number of idle connections maintained in the pool.
// Additional connections will be established to meet this value unless the pool is full.
config.pool.min = 1;

C#

cloud-sql/sql-server/Startup.cs 
// MaximumPoolSize sets maximum number of connections allowed in the pool.
connectionString.MaxPoolSize = 5;
// MinimumPoolSize sets the minimum number of connections in the pool.
connectionString.MinPoolSize = 0;

Go

cloudsql/sqlserver/database-sql/cloudsql.go 
// Set maximum number of connections in idle connection pool.
db.SetMaxIdleConns(5)

// Set maximum number of open connections to the database.
db.SetMaxOpenConns(7)

Ruby

cloud-sql/sqlserver/activerecord/config/database_tcp.yml 
# 'pool' is the maximum number of permanent connections to keep.
pool: 5

PHP

Al momento PDO non offre funzionalità per configurare i limiti di connessioni.

Backoff esponenziale

Se la tua applicazione tenta di connettersi al database e non riesce, il database potrebbe essere temporaneamente non disponibile. In questo caso, l'invio di troppe richieste di connessione simultanee potrebbe comportare lo spreco di risorse di database aggiuntive e l'aumento del tempo necessario per il ripristino. L'utilizzo di un backoff esponenziale impedisce all'applicazione di inviare un numero non reattivo di richieste di connessione quando non può connettersi al database.

Questo nuovo tentativo ha senso solo quando si connette per la prima volta o quando si acquisisce una connessione dal pool. Se si verificano errori durante una transazione, l'applicazione deve ripetere l'operazione e deve ripetere dall'inizio di una transazione. Quindi, anche se il pool è configurato correttamente, l'applicazione potrebbe comunque visualizzare errori in caso di perdita delle connessioni.

Python

cloud-sql/sql-server/sqlalchemy/connect_tcp.py 
# SQLAlchemy automatically uses delays between failed connection attempts,
# but provides no arguments for configuration.

Java

cloud-sql/sqlserver/servlet/src/main/java/com/example/cloudsql/ConnectionPoolFactory.java 
// Hikari automatically delays between failed connection attempts, eventually reaching a
// maximum delay of `connectionTimeout / 2` between attempts.

Node.js

cloud-sql/sqlserver/mssql/index.js 
// The node-mssql module uses a built-in retry strategy which does not implement backoff.
// 'createRetryIntervalMillis' is the number of milliseconds to wait in between retries.
config.pool.createRetryIntervalMillis = 200;

C#

cloud-sql/sql-server/Startup.cs 
Policy
    .Handle<SqlException>()
    .WaitAndRetry(new[]
    {
        TimeSpan.FromSeconds(1),
        TimeSpan.FromSeconds(2),
        TimeSpan.FromSeconds(5)
    })
    .Execute(() => connection.Open());

Go

Il pacchetto database/sql non offre attualmente alcuna funzionalità per configurare il backoff esponenziale.

Ruby

cloud-sql/sqlserver/activerecord/config/database_tcp.yml 
# ActiveRecord automatically uses delays between failed connection attempts,
# but provides no arguments for configuration.

PHP

Al momento PDO non offre funzionalità per configurare il backoff esponenziale.

Timeout connessione

Esistono molti motivi per cui un tentativo di connessione potrebbe non riuscire. Le comunicazioni di rete non sono mai garantite e il database potrebbe essere temporaneamente incapace di rispondere. Assicurati che la tua applicazione gestisca le connessioni interrotte o non riuscite correttamente.

Python

cloud-sql/sql-server/sqlalchemy/connect_tcp.py 
# 'pool_timeout' is the maximum number of seconds to wait when retrieving a
# new connection from the pool. After the specified amount of time, an
# exception will be thrown.
pool_timeout=30,  # 30 seconds

Java

cloud-sql/sqlserver/servlet/src/main/java/com/example/cloudsql/ConnectionPoolFactory.java 
// setConnectionTimeout is the maximum number of milliseconds to wait for a connection checkout.
// Any attempt to retrieve a connection from this pool that exceeds the set limit will throw an
// SQLException.
config.setConnectionTimeout(10000); // 10 seconds
// idleTimeout is the maximum amount of time a connection can sit in the pool. Connections that
// sit idle for this many milliseconds are retried if minimumIdle is exceeded.
config.setIdleTimeout(600000); // 10 minutes

Node.js

cloud-sql/sqlserver/mssql/index.js 
// 'connectionTimeout` is the maximum number of milliseconds to wait trying to establish an
// initial connection. After the specified amount of time, an exception will be thrown.
config.connectionTimeout = 30000;
// 'acquireTimeoutMillis' is the number of milliseconds before a timeout occurs when acquiring a
// connection from the pool.
config.pool.acquireTimeoutMillis = 30000;
// 'idleTimeoutMillis' is the number of milliseconds a connection must sit idle in the pool
// and not be checked out before it is automatically closed
(config.pool.idleTimeoutMillis = 600000),

C#

cloud-sql/sql-server/Startup.cs 
// ConnectionTimeout sets the time to wait (in seconds) while
// trying to establish a connection before terminating the attempt.
connectionString.ConnectTimeout = 15;

Go

Il pacchetto database/sql non offre attualmente alcuna funzionalità per configurare il timeout della connessione. Il timeout è configurato a livello di driver.

Ruby

cloud-sql/sqlserver/activerecord/config/database_tcp.yml 
# 'timeout' is the maximum number of seconds to wait when retrieving a
# new connection from the pool. After the specified amount of time, an
# ActiveRecord::ConnectionTimeoutError will be raised.
timeout: 5000

PHP

cloud_sql/sqlserver/pdo/src/DatabaseTcp.php 
// Here we set the connection timeout to five seconds and ask PDO to
// throw an exception if any errors occur.
[
    PDO::ATTR_TIMEOUT => 5,
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
]

Durata connessione

Limitare la durata di una connessione può contribuire a impedire l'accumulo di connessioni abbandonate. Puoi utilizzare il pool di connessioni per limitare la durata della connessione.

Python

cloud-sql/sql-server/sqlalchemy/connect_tcp.py 
# 'pool_recycle' is the maximum number of seconds a connection can persist.
# Connections that live longer than the specified amount of time will be
# re-established
pool_recycle=1800,  # 30 minutes

Java

cloud-sql/sqlserver/servlet/src/main/java/com/example/cloudsql/ConnectionPoolFactory.java 
// maxLifetime is the maximum possible lifetime of a connection in the pool. Connections that
// live longer than this many milliseconds will be closed and reestablished between uses. This
// value should be several minutes shorter than the database's timeout value to avoid unexpected
// terminations.
config.setMaxLifetime(1800000); // 30 minutes

Node.js

La libreria 'node-mssql' Node.js al momento non offre alcuna funzionalità per controllare la durata di una connessione.

C#

cloud-sql/sql-server/Startup.cs 
// ADO.NET connection pooler removes a connection
// from the pool after it's been idle for approximately
// 4-8 minutes, or if the pooler detects that the
// connection with the server no longer exists.

Go

cloudsql/sqlserver/database-sql/cloudsql.go 
// Set Maximum time (in seconds) that a connection can remain open.
db.SetConnMaxLifetime(1800 * time.Second)

Ruby

Attualmente ActiveRecord non offre alcuna funzionalità per controllare la durata di una connessione.

PHP

Al momento PDO non offre funzionalità per controllare la durata di una connessione.

Per visualizzare la domanda completa, fai clic sul link di seguito.

Python

Visualizza l'applicazione completa per il linguaggio di programmazione Python.

Node.js

Visualizza l'applicazione completa per il linguaggio di programmazione Node.js.

C#

Visualizza l'applicazione completa per il linguaggio di programmazione C#.

Go

Visualizza l'applicazione completa per il linguaggio di programmazione Go.

PHP

Visualizza l'applicazione completa per il linguaggio di programmazione PHP.

Passaggi successivi