Faça a gestão das ligações à base de dados

Esta página fornece práticas recomendadas e exemplos de código específicos do idioma para ajudar a criar aplicações que usam ligações à base de dados do Cloud SQL de forma eficaz.

Estas amostras são excertos de uma aplicação Web completa disponível para si no GitHub. Saiba mais.

Para ver instruções passo a passo sobre como executar uma aplicação Web de exemplo ligada ao Cloud SQL, siga o link para o seu ambiente:

Conjuntos de ligações

Um conjunto de ligações é uma cache de ligações à base de dados que são partilhadas e reutilizadas para melhorar a latência e o desempenho das ligações. Quando a sua aplicação precisa de uma ligação à base de dados, pede uma emprestada ao respetivo conjunto temporariamente. Quando a aplicação termina de usar a ligação, devolve-a ao conjunto, onde pode ser reutilizada da próxima vez que a aplicação precisar de uma ligação à base de dados.

Abrir e fechar ligações

Quando usa uma pool de ligações, tem de abrir e fechar as ligações corretamente, para que as ligações sejam sempre devolvidas à pool quando terminar de as usar. As ligações não devolvidas ou "roubadas" não são reutilizadas, o que desperdiça recursos e pode causar gargalos de desempenho para a sua aplicação.

Python

# 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, parameters={"time_cast": time_cast, "candidate": team})
        conn.commit()
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

// 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.
  String stmt = "INSERT INTO votes (time_cast, candidate) VALUES (?, ?);";
  try (PreparedStatement voteStmt = conn.prepareStatement(stmt);) {
    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

/**
 * Insert a vote record into the database.
 *
 * @param {object} pool The Knex connection object.
 * @param {object} vote The vote record to insert.
 * @returns {Promise}
 */
const insertVote = async (pool, vote) => {
  try {
    return await pool('votes').insert(vote);
  } catch (err) {
    throw Error(err);
  }
};

C#

using Npgsql;
using System;

namespace CloudSql
{
    public class PostgreSqlTcp
    {
        public static NpgsqlConnectionStringBuilder NewPostgreSqlTCPConnectionString()
        {
            // Equivalent connection string:
            // "Uid=<DB_USER>;Pwd=<DB_PASS>;Host=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new NpgsqlConnectionStringBuilder()
            {
                // 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.
                Host = Environment.GetEnvironmentVariable("INSTANCE_HOST"),     // e.g. '127.0.0.1'
                // Set Host to 'cloudsql' when deploying to App Engine Flexible environment
                Username = 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 = SslMode.Disable,
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Ir

insertVote := "INSERT INTO votes(candidate, created_at) VALUES($1, NOW())"
_, err := db.Exec(insertVote, team)

Ruby

@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

// Use prepared statements to guard against SQL injection.
$sql = 'INSERT INTO votes (time_cast, candidate) VALUES (NOW(), :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
    );
}

Número de ligações

Todas as ligações à base de dados usam recursos do lado do cliente e do lado do servidor. Além disso, o Cloud SQL impõe limites de ligação gerais que não podem ser excedidos. Criar e usar menos ligações reduz a sobrecarga e ajuda a manter-se abaixo do limite de ligações.

Python

# 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

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

// '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 Knex maintains in the pool.
// Additional connections will be established to meet this value unless the pool is full.
config.pool.min = 5;

C#

// MaxPoolSize sets maximum number of connections allowed in the pool.
connectionString.MaxPoolSize = 5;
// MinPoolSize sets the minimum number of connections in the pool.
connectionString.MinPoolSize = 0;

Ir

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

# 'pool' is the maximum number of permanent connections to keep.
pool: 5

PHP

Atualmente, o PDO não oferece qualquer funcionalidade para configurar limites de ligação.

Retirada exponencial

Se a sua aplicação tentar estabelecer ligação à base de dados e não o conseguir, a base de dados pode estar temporariamente indisponível. Neste caso, o envio de pedidos de ligação repetidos desperdiça recursos. É preferível aguardar antes de enviar pedidos de ligação adicionais para permitir que a base de dados volte a ficar acessível. A utilização de uma retirada exponencial ou outro mecanismo de atraso atinge este objetivo.

Esta nova tentativa só faz sentido quando se estabelece a ligação pela primeira vez ou quando se obtém uma ligação do conjunto pela primeira vez. Se ocorrerem erros a meio de uma transação, a aplicação tem de tentar novamente e tem de o fazer desde o início de uma transação. Assim, mesmo que o conjunto esteja configurado corretamente, a aplicação pode continuar a detetar erros se as ligações forem perdidas.

Python

# SQLAlchemy automatically uses delays between failed connection attempts,
# but provides no arguments for configuration.

Java

// Hikari automatically delays between failed connection attempts, eventually reaching a
// maximum delay of `connectionTimeout / 2` between attempts.

Node.js

// 'knex' uses a built-in retry strategy which does not implement backoff.
// 'createRetryIntervalMillis' is how long to idle after failed connection creation before trying again
config.pool.createRetryIntervalMillis = 200; // 0.2 seconds

C#

Policy
    .Handle<NpgsqlException>()
    .WaitAndRetry(new[]
    {
        TimeSpan.FromSeconds(1),
        TimeSpan.FromSeconds(2),
        TimeSpan.FromSeconds(5)
    })
    .Execute(() => connection.Open());

Ir

Atualmente, o pacote database/sql não oferece nenhuma funcionalidade para configurar o recuo exponencial.

Ruby

# ActiveRecord automatically uses delays between failed connection attempts,
# but provides no arguments for configuration.

PHP

Atualmente, o PDO não oferece nenhuma funcionalidade para configurar o recuo exponencial.

Limite de tempo da ligação

Existem muitos motivos pelos quais uma tentativa de ligação pode não ter êxito. A comunicação de rede nunca é garantida e a base de dados pode não conseguir responder temporariamente. Certifique-se de que a sua aplicação processa as ligações danificadas ou sem êxito de forma adequada.

Python

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

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

// 'acquireTimeoutMillis' is the number of milliseconds before a timeout occurs when acquiring a
// connection from the pool. This is slightly different from connectionTimeout, because acquiring
// a pool connection does not always involve making a new connection, and may include multiple retries.
// when making a connection
config.pool.acquireTimeoutMillis = 60000; // 60 seconds
// 'createTimeoutMillis` is the maximum number of milliseconds to wait trying to establish an
// initial connection before retrying.
// After acquireTimeoutMillis has passed, a timeout exception will be thrown.
config.pool.createTimeoutMillis = 30000; // 30 seconds
// '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; // 10 minutes

C#

// Timeout sets the time to wait (in seconds) while
// trying to establish a connection before terminating the attempt.
connectionString.Timeout = 15;

Ir

Atualmente, o pacote database/sql não oferece nenhuma funcionalidade para configurar o limite de tempo da ligação. O limite de tempo é configurado ao nível do controlador.

Ruby

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

// 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,
]

Duração da ligação

Limitar a duração de uma ligação pode ajudar a evitar a acumulação de ligações abandonadas. Pode usar o conjunto de ligações para limitar a duração das ligações.

Python

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

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

Atualmente, a biblioteca Node.js "knex" não oferece qualquer funcionalidade para controlar a duração de uma ligação.

C#

// ConnectionIdleLifetime sets the time (in seconds) to wait before
// closing idle connections in the pool if the count of all
// connections exceeds MinPoolSize.
connectionString.ConnectionIdleLifetime = 300;

Ir

// Set Maximum time (in seconds) that a connection can remain open.
db.SetConnMaxLifetime(1800 * time.Second)

Ruby

Atualmente, o ActiveRecord não oferece qualquer funcionalidade para controlar a duração de uma ligação.

PHP

Atualmente, o PDO não oferece qualquer funcionalidade para controlar a duração de uma ligação.

Para ver a candidatura completa, clique no link abaixo.

Python

Veja a aplicação completa para a linguagem de programação Python.

Java

Veja a aplicação completa para a linguagem de programação Java.

Node.js

Veja a aplicação completa para a linguagem de programação Node.js.

C#

Veja a aplicação completa para a linguagem de programação C#.

Ir

Veja a aplicação completa para a linguagem de programação Go.

Ruby

Veja a aplicação completa para a linguagem de programação Ruby.

PHP

Veja a candidatura completa para a linguagem de programação PHP.

O que se segue?