Conectarse mediante el proxy de autenticación de Cloud SQL

Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Esta página describe cómo conectarse a su instancia de Cloud SQL mediante el proxy de autenticación de Cloud SQL.

Para obtener más información sobre cómo funciona el proxy de autenticación de Cloud SQL, consulte Acerca del proxy de autenticación de Cloud SQL .

Descripción general

El proxy de autenticación de Cloud SQL es el método recomendado para conectarse a una instancia de Cloud SQL. El proxy de autenticación de Cloud SQL:

• Funciona con puntos finales de IP públicos y privados
• Valida las conexiones utilizando credenciales para una cuenta de usuario o servicio
• Envuelve la conexión en una capa SSL/TLS autorizada para una instancia de Cloud SQL

Alguno Google Cloud Los servicios y aplicaciones utilizan Cloud SQL Auth Proxy para proporcionar conexiones para rutas de IP públicas con cifrado y autorización, incluidos:

• Entorno estándar de App Engine
• Entorno flexible de App Engine
• Funciones de Cloud Run
• Carrera en la nube

Las aplicaciones que se ejecutan en Google Kubernetes Engine pueden conectarse mediante el proxy de autenticación de Cloud SQL.

Consulta la Guía de inicio rápido para usar el proxy de autenticación de Cloud SQL para obtener una introducción básica a su uso.

También puede conectarse, con o sin Cloud SQL Auth Proxy, utilizando un cliente sqlcmd desde una máquina local o Compute Engine .

Antes de empezar

Antes de poder conectarse a una instancia de Cloud SQL, haga lo siguiente:

1. • Para una cuenta de usuario o servicio, asegúrese de que tenga el rol de cliente de Cloud SQL. Este rol contiene el permiso cloudsql.instances.connect , que autoriza a una entidad de seguridad a conectarse a todas las instancias de Cloud SQL de un proyecto.

     Ir a la página de IAM

   • Opcionalmente, puede incluir una condición de IAM en el enlace de la política de IAM que otorgue a la cuenta permiso para conectarse solo a una instancia específica de Cloud SQL.

2. Enable the Cloud SQL Admin API.

   Enable the API

3. Instalar e inicializar la CLI de gcloud .
4. Opcional. Instale el cliente Docker del proxy de autenticación de Cloud SQL .

Descargar el proxy de autenticación de Cloud SQL

docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.16.0

Iniciar el proxy de autenticación de Cloud SQL

Puede iniciar el proxy de autenticación de Cloud SQL mediante sockets TCP o la imagen Docker del proxy de autenticación de Cloud SQL. El binario del proxy de autenticación de Cloud SQL se conecta a una o más instancias de Cloud SQL especificadas en la línea de comandos y abre una conexión local como un socket TCP. Otras aplicaciones y servicios, como el código de su aplicación o las herramientas cliente de administración de bases de datos, pueden conectarse a las instancias de Cloud SQL a través de esa conexión de socket TCP.

./cloud-sql-proxy --address 0.0.0.0 --port 1234 INSTANCE_CONNECTION_NAME

gcloud sql instances describe INSTANCE_NAME

docker run -d \\
  -v PATH_TO_KEY_FILE:/path/to/service-account-key.json \\
  -p 127.0.0.1:1433:1433 \\
  gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.16.0 \\
  --address 0.0.0.0 --port 1433 \\
  --credentials-file /path/to/service-account-key.json INSTANCE_CONNECTION_NAME

docker run -d -v /cloudsql:/cloudsql \\
  -v PATH_TO_KEY_FILE:/path/to/service-account-key.json \\
  gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.16.0 --unix-socket=/cloudsql \\
  --credentials-file /path/to/service-account-key.json INSTANCE_CONNECTION_NAME

-v /mnt/stateful_partition/cloudsql:/cloudsql

Conectarse con el cliente sqlcmd

La cadena de conexión que utilice dependerá de si inició el proxy de autenticación de Cloud SQL mediante un socket TCP o Docker.

¿Necesitas ayuda? Para solucionar problemas con el proxy, consulta "Solucionar problemas de conexión con el proxy de autenticación de Cloud SQL" o nuestra página de soporte de Cloud SQL .

Conectarse con una aplicación

Puedes conectarte al proxy de autenticación de Cloud SQL desde cualquier lenguaje que te permita conectarte a un socket TCP. A continuación, se muestran fragmentos de código de ejemplos completos en GitHub para ayudarte a comprender cómo funcionan juntos en tu aplicación.

./cloud-sql-proxy INSTANCE_CONNECTION_NAME &

import os

import sqlalchemy


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

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

    return pool

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

public class TcpConnectionPoolFactory 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 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();

    // Configure which instance and what database user to connect with.
    config.setJdbcUrl(
        String.format("jdbc:sqlserver://%s:%s;databaseName=%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "sqlserver"
    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);
  }
}

const mssql = require('mssql');

// createTcpPool initializes a TCP connection pool for a Cloud SQL
// instance of SQL Server.
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 = {
    server: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
    port: parseInt(process.env.DB_PORT), // e.g. 1433
    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'
    options: {
      trustServerCertificate: true,
    },
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return mssql.connect(dbConfig);
};

package cloudsql

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

	_ "github.com/denisenkom/go-mssqldb"
)

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

	dbURI := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%s;database=%s;",
		dbTCPHost, dbUser, dbPwd, dbPort, dbName)


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

	// ...

	return dbPool, nil
}

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

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

namespace Google\Cloud\Samples\CloudSQL\SQLServer;

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(
                'sqlsrv:server=%s;Database=%s',
                $instanceHost,
                $dbName
            );

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

        return $conn;
    }
}

Temas adicionales

Argumentos de la línea de comandos del proxy de autenticación de Cloud SQL

Los ejemplos anteriores abarcan los casos de uso más comunes, pero el proxy de autenticación de Cloud SQL también ofrece otras opciones de configuración que pueden configurarse mediante argumentos de línea de comandos. Para obtener ayuda sobre los argumentos de línea de comandos, utilice el indicador --help para consultar la documentación más reciente:

./cloud-sql-proxy --help

Consulte el archivo README en el repositorio de GitHub de Cloud SQL Auth Proxy para obtener ejemplos adicionales de cómo usar las opciones de la línea de comandos de Cloud SQL Auth Proxy.

Opciones para autenticar el proxy de autenticación de Cloud SQL

Todas estas opciones utilizan un INSTANCE_CONNECTION_NAME como cadena de conexión para identificar una instancia de Cloud SQL. Puede encontrar el INSTANCE_CONNECTION_NAME en la página de descripción general de su instancia en Google Cloud consola . o ejecutando el siguiente comando:

gcloud sql instances describe --project PROJECT_ID INSTANCE_CONNECTION_NAME .

Por ejemplo: gcloud sql instances describe --project myproject myinstance .

Algunas de estas opciones utilizan un archivo de credenciales JSON que incluye la clave privada RSA de la cuenta. Para obtener instrucciones sobre cómo crear un archivo de credenciales JSON para una cuenta de servicio, consulte "Crear una cuenta de servicio" .

El proxy de autenticación de Cloud SQL ofrece varias alternativas de autenticación, según el entorno. El proxy de autenticación de Cloud SQL comprueba cada uno de los siguientes elementos, en el orden indicado, utilizando el primero que encuentra para intentar la autenticación:

1. Credenciales proporcionadas por el indicador de archivo de credenciales.

   Use una cuenta de servicio para crear y descargar el archivo JSON asociado y configure el indicador --credentials-file en la ruta del archivo al iniciar el proxy de autenticación de Cloud SQL. La cuenta de servicio debe tener los permisos necesarios para la instancia de Cloud SQL.

   Para usar esta opción en la línea de comandos, invoque el comando cloud-sql-proxy con el indicador --credentials-file establecido en la ruta y el nombre de un archivo de credenciales JSON. La ruta puede ser absoluta o relativa al directorio de trabajo actual. Por ejemplo:

   ./cloud-sql-proxy --credentials-file PATH_TO_KEY_FILE \
   INSTANCE_CONNECTION_NAME
     

   Para obtener instrucciones detalladas sobre cómo agregar roles de IAM a una cuenta de servicio, consulte Otorgar roles a cuentas de servicio .

   Para obtener más información sobre los roles que admite Cloud SQL, consulte Roles de IAM para Cloud SQL .

2. Credenciales proporcionadas por un token de acceso.

   Cree un token de acceso e invoque el comando cloud-sql-proxy con el indicador --token establecido en un token de acceso OAuth 2.0. Por ejemplo:

   ./cloud-sql-proxy --token ACCESS_TOKEN \
   INSTANCE_CONNECTION_NAME
     

3. Credenciales proporcionadas por una variable de entorno.

   Esta opción es similar a usar el indicador --credentials-file , excepto que especifica el archivo de credenciales JSON que configuró en la variable de entorno GOOGLE_APPLICATION_CREDENTIALS en lugar de usar el argumento de línea de comandos --credentials-file .

4. Credenciales de un cliente CLI de gcloud autenticado.

   Si instaló la CLI de gcloud y se autenticó con su cuenta personal, el proxy de autenticación de Cloud SQL puede usar las mismas credenciales. Este método es especialmente útil para poner en marcha un entorno de desarrollo.

   Para permitir que el proxy de autenticación de Cloud SQL use sus credenciales de gcloud CLI, use el siguiente comando para autenticar gcloud CLI:

   gcloud auth application-default login

5. Credenciales asociadas con la instancia de Compute Engine.

   Si se conecta a Cloud SQL desde una instancia de Compute Engine, el proxy de autenticación de Cloud SQL puede usar la cuenta de servicio asociada a dicha instancia. Si la cuenta de servicio tiene los permisos necesarios para la instancia de Cloud SQL, el proxy de autenticación de Cloud SQL se autenticará correctamente.

   Si la instancia de Compute Engine está en el mismo proyecto que la instancia de Cloud SQL, la cuenta de servicio predeterminada de la instancia de Compute Engine tiene los permisos necesarios para autenticar el proxy de autenticación de Cloud SQL. Si ambas instancias están en proyectos diferentes, debe agregar la cuenta de servicio de la instancia de Compute Engine al proyecto que contiene la instancia de Cloud SQL.

6. Cuenta de servicio predeterminada del entorno

   Si el proxy de autenticación de Cloud SQL no encuentra credenciales en ninguno de los lugares mencionados anteriormente, sigue la lógica documentada en Configuración de la autenticación para aplicaciones de producción de servidor a servidor . Algunos entornos (como Compute Engine, App Engine, etc.) proporcionan una cuenta de servicio predeterminada que la aplicación puede usar para autenticarse de forma predeterminada. Si usa una cuenta de servicio predeterminada, debe tener los permisos descritos en roles y permisos. Para obtener más información sobre el enfoque de autenticación de Google Cloud, consulte Descripción general de la autenticación .

Crear una cuenta de servicio

1. En el Google Cloud consola, vaya a la página Cuentas de servicio .

   Ir a Cuentas de servicio

2. Seleccione el proyecto que contiene su instancia de Cloud SQL.
3. Haga clic en Crear cuenta de servicio .
4. En el campo Nombre de la cuenta de servicio , ingrese un nombre descriptivo para la cuenta de servicio.
5. Cambie el ID de la cuenta de servicio a un valor único y reconocible y luego haga clic en Crear y continuar .
6. Haga clic en el campo Seleccionar un rol y seleccione uno de los siguientes roles:
   • Cloud SQL > Cliente de Cloud SQL
   • Cloud SQL > Editor de Cloud SQL
   • Cloud SQL > Administrador de Cloud SQL

7. Haga clic en Listo para finalizar la creación de la cuenta de servicio.
8. Haga clic en el menú de acciones de su nueva cuenta de servicio y luego seleccione Administrar claves .
9. Haga clic en el menú desplegable Agregar clave y luego haga clic en Crear nueva clave .
10. Confirme que el tipo de clave sea JSON y luego haga clic en Crear .

    El archivo de clave privada se descarga en tu equipo. Puedes moverlo a otra ubicación. Mantén el archivo de clave seguro.

Utilice el proxy de autenticación de Cloud SQL con IP privada

Para conectarse a una instancia de Cloud SQL mediante una IP privada, el proxy de autenticación de Cloud SQL debe estar en un recurso con acceso a la misma red de VPC que la instancia.

El proxy de autenticación de Cloud SQL usa la dirección IP para establecer una conexión con su instancia de Cloud SQL. De forma predeterminada, intenta conectarse mediante una dirección IPv4 pública.

Si su instancia de Cloud SQL solo tiene una IP privada o tiene configuradas una IP pública y una privada, y desea que el proxy de autenticación de Cloud SQL use la dirección IP privada, debe proporcionar la siguiente opción cuando inicie el proxy de autenticación de Cloud SQL:

--private-ip

Utilice el proxy de autenticación de Cloud SQL con instancias que tengan habilitada la Conexión de servicio privado

Puede usar el proxy de autenticación de Cloud SQL para conectarse a una instancia de Cloud SQL con la conexión de servicio privado habilitada.

El proxy de autenticación de Cloud SQL es un conector que proporciona acceso seguro a esta instancia sin necesidad de redes autorizadas ni de configurar SSL.

Para permitir conexiones de cliente de Cloud SQL Auth Proxy, debe configurar un registro DNS que coincida con el nombre DNS recomendado proporcionado para la instancia. El registro DNS es una correspondencia entre un recurso DNS y un nombre de dominio.

Para obtener más información sobre cómo usar el proxy de autenticación de Cloud SQL para conectarse a instancias con Private Service Connect habilitado, consulte Conectarse mediante el proxy de autenticación de Cloud SQL .

Ejecute el proxy de autenticación de Cloud SQL en un proceso separado

Ejecutar el proxy de autenticación de Cloud SQL en un proceso de terminal de Cloud Shell independiente puede ser útil para evitar mezclar la salida de la consola con la de otros programas. Utilice la sintaxis que se muestra a continuación para invocar el proxy de autenticación de Cloud SQL en un proceso independiente.

./cloud-sql-proxy INSTANCE_CONNECTION_NAME
  --credentials-file PATH_TO_KEY_FILE &

Start-Process --filepath "cloud-sql-proxy.exe"
  --ArgumentList "
  --credentials-file PATH_TO_KEY_FILEINSTANCE_CONNECTION_NAME"

Ejecute el proxy de autenticación de Cloud SQL en un contenedor Docker

Para ejecutar el proxy de autenticación de Cloud SQL en un contenedor Docker, use la imagen Docker del proxy de autenticación de Cloud SQL disponible en Google Container Registry . Puede instalar la imagen Docker del proxy de autenticación de Cloud SQL con el siguiente comando:

docker pull gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.16.0

Puede iniciar el proxy de autenticación de Cloud SQL mediante sockets TCP o sockets Unix, con los comandos que se muestran a continuación.

    docker run -d \
      -v PATH_TO_KEY_FILE:/path/to/service-account-key.json \
      -p 127.0.0.1:1433:1433 \
      gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.16.0 \
      --address 0.0.0.0 \
      --credentials-file /path/to/service-account-key.json \
      INSTANCE_CONNECTION_NAME

    docker run -d \
      -v /PATH_TO_HOST_TARGET:/PATH_TO_GUEST_TARGET \
      -v PATH_TO_KEY_FILE:/path/to/service-account-key.json \
      gcr.io/cloud-sql-connectors/cloud-sql-proxy:2.16.0 --unix-socket /cloudsql \
      --credentials-file /path/to/service-account-key.json/PATH_TO_KEY_FILE \
      INSTANCE_CONNECTION_NAME

Si está utilizando una imagen optimizada para contenedores, utilice un directorio en el que se pueda escribir en lugar de /cloudsql , por ejemplo:

v /mnt/stateful_partition/cloudsql:/cloudsql

Si está utilizando las credenciales proporcionadas por su instancia de Compute Engine, no incluya el parámetro credential_file ni la línea -v PATH_TO_KEY_FILE :/path/to/service-account-key.json .

Ejecución del proxy de autenticación de Cloud SQL como servicio

Ejecutar el proxy de autenticación de Cloud SQL como servicio en segundo plano es una opción para cargas de trabajo de desarrollo y producción locales. Durante el desarrollo, cuando necesite acceder a su instancia de Cloud SQL, puede iniciar el servicio en segundo plano y detenerlo al finalizar.

Para cargas de trabajo de producción, el proxy de autenticación de Cloud SQL actualmente no ofrece compatibilidad integrada para ejecutarse como servicio de Windows, pero se pueden usar administradores de servicios de terceros para ejecutarlo como tal. Por ejemplo, puede usar NSSM para configurar el proxy de autenticación de Cloud SQL como servicio de Windows, y NSSM lo monitoriza y lo reinicia automáticamente si deja de responder. Consulte la documentación de NSSM para obtener más información.

Conectarse cuando se requiere SSL

Imponer el uso del proxy de autenticación de Cloud SQL

Habilite el uso del proxy de autenticación de Cloud SQL en Cloud SQL mediante ConnectorEnforcement .

Si utiliza una instancia con Private Service Connect habilitado , existe una limitación. Si la instancia tiene habilitada la aplicación de conectores, no podrá crear réplicas de lectura para ella. De igual forma, si la instancia tiene réplicas de lectura, tampoco podrá habilitar la aplicación de conectores para ella.

    gcloud sql instances patch INSTANCE_NAME \
    --connector-enforcement REQUIRED
  

PATCH https://sqladmin.googleapis.com/v1/projects/project-id/instances/instance-id

{
  "settings": {                     
    "connectorEnforcement": "REQUIRED"    
  }                                             
}   

curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://sqladmin.googleapis.com/v1/projects/project-id/instances/instance-id"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method PATCH `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://sqladmin.googleapis.com/v1/projects/project-id/instances/instance-id" | Select-Object -Expand Content

{
  "kind": "sql#operation",
  "targetLink": "https://sqladmin.googleapis.com/v1/projects/project-id/instances/instance-id",
  "status": "PENDING",
  "user": "[email protected]",
  "insertTime": "2020-01-16T02:32:12.281Z",
  "operationType": "UPDATE",
  "name": "operation-id",
  "targetId": "instance-id",
  "selfLink": "https://sqladmin.googleapis.com/v1/projects/project-id/operations/operation-id",
  "targetProject": "project-id"
}

PATCH https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/instances/instance-id

{
  "settings": {
    "connectorEnforcement": "REQUIRED"
  }
}

curl -X PATCH \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/instances/instance-id"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method PATCH `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/instances/instance-id" | Select-Object -Expand Content

{
  "kind": "sql#operation",
  "targetLink": "https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/instances/instance-id",
  "status": "PENDING",
  "user": "[email protected]",
  "insertTime": "2020-01-16T02:32:12.281Z",
  "operationType": "UPDATE",
  "name": "operation-id",
  "targetId": "instance-id",
  "selfLink": "https://sqladmin.googleapis.com/sql/v1beta4/projects/project-id/operations/operation-id",
  "targetProject": "project-id"
}

Consejos para trabajar con Cloud SQL Auth Proxy

Utilice el proxy de autenticación de Cloud SQL para conectarse a varias instancias

Puedes usar un cliente proxy de autenticación de Cloud SQL local para conectarte a varias instancias de Cloud SQL. La forma de hacerlo depende de si usas sockets Unix o TCP.

    # Start the Cloud SQL Auth Proxy to connect to two different Cloud SQL instances.
    # Give the Cloud SQL Auth Proxy a unique port on your machine to use for each Cloud SQL instance.

    ./cloud-sql-proxy "myProject:us-central1:myInstance?port=1433" \
    "myProject:us-central1:myInstance2?port=1234"

    # Connect to "myInstance" using port 1433 on your machine:
    sqlcmd -U myUser -S "127.0.0.1,1433"

    # Connect to "myInstance2" using port 1234 on your machine:
    sqlcmd -U myUser -S "127.0.0.1,1234"
  

Solucionar problemas de conexión del proxy de autenticación de Cloud SQL

La imagen Docker del proxy de autenticación de Cloud SQL se basa en una versión específica del mismo. Cuando esté disponible una nueva versión, descargue la imagen Docker del proxy de autenticación de Cloud SQL para mantener su entorno actualizado. Puede consultar la versión actual del proxy de autenticación de Cloud SQL en la página de versiones de GitHub del proxy de autenticación de Cloud SQL .

Si tiene problemas para conectarse a su instancia de Cloud SQL mediante el proxy de autenticación de Cloud SQL, aquí hay algunas cosas que puede intentar para encontrar la causa del problema.

• Verifique que esté utilizando la dirección IP para conectarse a la instancia y no el punto final de escritura .

• Verifique la salida del proxy de autenticación de Cloud SQL.

  A menudo, la salida del proxy de autenticación de Cloud SQL puede ayudarte a determinar el origen del problema y cómo solucionarlo. Transfiere la salida a un archivo o consulta la terminal de Cloud Shell donde iniciaste el proxy de autenticación de Cloud SQL.

• Si recibe un error 403 notAuthorized y está usando una cuenta de servicio para autenticar el proxy de autenticación de Cloud SQL, asegúrese de que la cuenta de servicio tenga los permisos correctos.

  Puede comprobar la cuenta de servicio buscando su ID en la página IAM . Debe tener el permiso cloudsql.instances.connect . Los roles predefinidos de administrador, Client y Editor Cloud SQL Admin tienen este permiso.

• Si te conectas desde App Engine y recibes un error 403 notAuthorized , revisa el valor cloud_sql_instances app.yaml para ver si el nombre de la conexión de instancia está mal escrito o es incorrecto. Los nombres de las conexiones de instancia siempre tienen el formato PROJECT:REGION:INSTANCE .

  Además, verifique que la cuenta de servicio de App Engine (por ejemplo, [email protected]) tiene el rol de IAM de cliente de Cloud SQL.

  Si el servicio de App Engine reside en un proyecto (proyecto A) y la base de datos reside en otro (proyecto B), este error significa que a la cuenta del servicio de App Engine no se le ha otorgado el rol de IAM de cliente de Cloud SQL en el proyecto con la base de datos (proyecto B).

• Asegúrese de habilitar la API de administración de Cloud SQL.

  Si no es así, verá un resultado como Error 403: Access Not Configured en los registros del proxy de autenticación de Cloud SQL.

• Si incluye varias instancias en su lista, asegúrese de usar una coma como delimitador, sin espacios. Si usa TCP, asegúrese de especificar puertos diferentes para cada instancia.

• Si se conecta mediante sockets UNIX, confirme que los sockets se crearon indicando el directorio que proporcionó cuando inició el proxy de autenticación de Cloud SQL.

• Si tiene una política de firewall de salida, asegúrese de que permita conexiones al puerto 3307 en la instancia de Cloud SQL de destino.

• Puede confirmar que el proxy de autenticación de Cloud SQL se inició correctamente consultando los registros en la sección Operaciones > Registro > Explorador de registros delGoogle Cloud consola. Una operación exitosa se ve así:

  2021/06/14 15:47:56 Listening on /cloudsql/$PROJECT_ID:$REGION:$INSTANCE_NAME/1433 for $PROJECT_ID:$REGION:$INSTANCE_NAME
  2021/06/14 15:47:56 Ready for new connections
  

• Problemas de cuota: cuando se supera la cuota de la API de administración de Cloud SQL, el proxy de autenticación de Cloud SQL se inicia con el siguiente mensaje de error:

  There was a problem when parsing a instance configuration but ignoring due
  to the configuration. Error: googleapi: Error 429: Quota exceeded for quota
  metric 'Queries' and limit 'Queries per minute per user' of service
  'sqladmin.googleapis.com' for consumer 'project_number:$PROJECT_ID.,
  rateLimitExceeded
  

  Una vez que una aplicación se conecta al proxy, este informa el siguiente error:

  failed to refresh the ephemeral certificate for $INSTANCE_CONNECTION_NAME:
  googleapi: Error 429: Quota exceeded for quota metric 'Queries' and limit
  'Queries per minute per user' of service 'sqladmin.googleapis.com' for
  consumer 'project_number:$PROJECT_ID., rateLimitExceeded
  

  Solución: Identifique el origen del problema de cuota (por ejemplo, si una aplicación está haciendo un mal uso del conector y creando nuevas conexiones innecesarias) o contacte con el equipo de soporte para solicitar un aumento de la cuota de la API de administración de Cloud SQL. Si el error de cuota aparece al iniciar, debe volver a implementar la aplicación para reiniciar el proxy. Si el error de cuota aparece después del inicio, no es necesario volver a implementarla.

¿Qué sigue?

• Obtenga más información sobre el proxy de autenticación de Cloud SQL .
• Obtenga más información sobre la gestión de identidad y acceso (IAM) .
• Obtenga más información sobre las cuentas de servicio .
• Obtenga información sobre los dos niveles de control de acceso para instancias de Cloud SQL.
• Crear usuarios y bases de datos .
• Obtenga información sobre cómo conectarse a su instancia desde su aplicación .
• Conozca las opciones de soporte .