Administra conexiones de bases de datos

En esta página, se proporcionan prácticas recomendadas y muestras de código de lenguaje específico para ayudarte a crear aplicaciones que usan conexiones con la base de datos de Cloud SQL de manera eficiente.

Estas muestras son extractos de una aplicación completa de App Engine disponible para ti en GitHub. Más información

Grupos de conexiones

Un grupo de conexiones es una caché de conexiones con la base de datos que se comparten y reutilizan para mejorar la latencia y el rendimiento de la conexión. Cuando la aplicación necesita una conexión con la base de datos, toma una prestada del grupo de manera temporal; cuando la aplicación ya no usa la conexión, la devuelve al grupo para reutilizarla la próxima vez que la aplicación necesite una conexión con la base de datos.

Abre y cierra conexiones

Cuando usas un grupo de conexiones, debes abrir y cerrar las conexiones de forma correcta, de modo que tus conexiones siempre vuelvan al grupo cuando hayas terminado con ellas. Las conexiones que no se devuelvan o que se “filtren” no se podrán volver a usar, lo que lleva a la pérdida de recursos y puede provocar cuellos de botella de rendimiento en la aplicación.

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

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

insertTimestamp = DateTime.UtcNow;
try
{
    using(var connection = new NpgsqlConnection(_connectionString.ConnectionString))
    {
        connection.OpenWithRetry();
        using (var insertVoteCommand = connection.CreateCommand())
        {
            insertVoteCommand.CommandText =
                @"INSERT INTO votes (candidate, time_cast) VALUES (@candidate, @time_cast)";
            var candidate = insertVoteCommand.CreateParameter();
            candidate.ParameterName = "@candidate";
            candidate.DbType = DbType.String;
            candidate.Value = team;
            insertVoteCommand.Parameters.Add(candidate);
            var timeCast = insertVoteCommand.CreateParameter();
            timeCast.ParameterName = "@time_cast";
            timeCast.DbType = DbType.DateTime;
            timeCast.Value = insertTimestamp;
            insertVoteCommand.Parameters.Add(timeCast);
            await insertVoteCommand.ExecuteNonQueryAsync();
        }
    }
    return Content($"Vote successfully cast for '{team}' at time {insertTimestamp}!");
}
catch (Exception ex)
{
    // If something goes wrong, handle the error in this
    // section. This might involve retrying or adjusting
    // parameters depending on the situation.
    return StatusCode((int)HttpStatusCode.InternalServerError, ex);
}

Comienza a usarlo

sqlInsert := "INSERT INTO votes(candidate, created_at, updated_at) VALUES($1, NOW(), NOW())"
if team == "TABS" || team == "SPACES" {
	if _, err := app.db.Exec(sqlInsert, team); err != nil {
		fmt.Fprintf(w, "unable to save vote: %s", err)
		return fmt.Errorf("DB.Exec: %v", err)
	}
	fmt.Fprintf(w, "Vote successfully cast for %s!\n", team)
}
return nil

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

Conteo de conexiones

Cada conexión con la base de datos utiliza recursos de cliente y servidor. Además, Cloud SQL impone límites de conexión que no se pueden exceder. Mediante la creación y el uso de menos conexiones se reduce la sobrecarga y esto te ayuda a no superar el límite de conexiones.

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;

Comienza a usarlo


// Set maximum number of connections in idle connection pool.
dbPool.SetMaxIdleConns(5)

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

Ruby

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

PHP

Por el momento, PDO no ofrece ninguna función para configurar los límites de conexión.

Retirada exponencial

Si la aplicación intenta conectarse con la base de datos y no lo logra, es posible que la base de datos no esté disponible temporalmente. En este caso, el envío simultáneo de demasiadas solicitudes de conexión puede generar un gasto innecesario de recursos adicionales de base de datos y aumentar el tiempo de recuperación. El uso de la retirada exponencial evita que la aplicación envíe solicitudes de conexión que no responden cuando no se puede conectar a la base de datos.

Este reintento solo tiene sentido cuando te conectas o tomas una conexión del grupo por primera vez. Si se producen errores en el medio de una transacción, la aplicación debe volver a intentarla desde el comienzo. Por lo tanto, incluso si el grupo está configurado de forma correcta, es posible que la aplicación detecte errores si se pierden las conexiones.

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

Comienza a usarlo

Por el momento, el paquete database/sql no ofrece ninguna función para configurar la retirada exponencial.

Ruby

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

PHP

Por el momento, PDO no ofrece ninguna función para configurar la retirada exponencial.

Tiempo de espera de la conexión

Existen diferentes razones por las cuales un intento de conexión puede fallar. La comunicación con la red nunca se garantiza, y es posible que la base de datos no esté disponible temporalmente para responder. Asegúrate de que la aplicación gestione las conexiones dañadas o que no funcionan con facilidad.

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;

Comienza a usarlo

Por el momento, el paquete database/sql no ofrece ninguna función para configurar el tiempo de espera de la conexión. El tiempo de espera se configura a nivel de 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.
$connConfig = [
    PDO::ATTR_TIMEOUT => 5,
    PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
];

Duración de la conexión

Poner un límite al tiempo de actividad de conexión puede ayudar a evitar que se acumulen conexiones abandonadas. Puedes usar el grupo de conexiones para limitar el tiempo de actividad de la conexión.

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
# reestablished
"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

En la actualidad, la biblioteca “knex” de Node.js no ofrece ninguna funcionalidad para controlar la duración de una conexión.

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;

Comienza a usarlo


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

Ruby

Por el momento, ActiveRecord no ofrece ninguna función para controlar la duración de una conexión.

PHP

Por el momento, PDO no ofrece ninguna función para controlar la duración de una conexión.

Para ver la aplicación completa, haz clic en el siguiente vínculo.

Python

Ver la aplicación completa para el lenguaje de programación Python.

Java

Ve la aplicación completa para el lenguaje de programación Java.

Node.js

Ve la aplicación completa para el lenguaje de programación Node.js.

C#

Ve la solicitud completa para el lenguaje de programación C#.

Comienza a usarlo

Visualiza la aplicación completa para el lenguaje de programación Go.

Ruby

Visualiza la aplicación completa para el lenguaje de programación Ruby.

PHP

Visualiza la aplicación completa para el lenguaje de programación PHP.

Próximos pasos