Conecte-se usando o Cloud SQL Auth Proxy

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Esta página descreve como se conectar à sua instância do Cloud SQL usando o Cloud SQL Auth Proxy.

Para obter mais informações sobre como o Cloud SQL Auth Proxy funciona, consulte Sobre o Cloud SQL Auth Proxy .

Visão geral

O método recomendado para se conectar a uma instância do Cloud SQL é o Proxy de Autenticação do Cloud SQL. O Proxy de Autenticação do Cloud SQL:

• Funciona com endpoints IP públicos e privados
• Valida conexões usando credenciais para uma conta de usuário ou serviço
• Envolve a conexão em uma camada SSL/TLS autorizada para uma instância do Cloud SQL

Alguns Google Cloud serviços e aplicativos usam o Cloud SQL Auth Proxy para fornecer conexões para caminhos IP públicos com criptografia e autorização, incluindo:

• Ambiente padrão do App Engine
• Ambiente flexível do App Engine
• Funções do Cloud Run
• Corrida na Nuvem

Os aplicativos em execução no Google Kubernetes Engine podem se conectar usando o Cloud SQL Auth Proxy.

Consulte o Início rápido para usar o Cloud SQL Auth Proxy para uma introdução básica ao seu uso.

Você também pode se conectar, com ou sem o Cloud SQL Auth Proxy, usando um cliente sqlcmd de uma máquina local ou do Compute Engine .

Antes de começar

Antes de se conectar a uma instância do Cloud SQL, faça o seguinte:

1. • Para uma conta de usuário ou serviço, certifique-se de que a conta tenha a função de Cliente do Cloud SQL. Essa função contém a permissão cloudsql.instances.connect , que autoriza um principal a se conectar a todas as instâncias do Cloud SQL em um projeto.

     Acesse a página do IAM

   • Opcionalmente, você pode incluir uma condição do IAM na vinculação da política do IAM que concede à conta permissão para se conectar apenas a uma instância específica do Cloud SQL.

2. Enable the Cloud SQL Admin API.

   Enable the API

3. Instale e inicialize o gcloud CLI .
4. Opcional. Instale o cliente Docker do Cloud SQL Auth Proxy .

Baixe o proxy de autenticação do Cloud SQL

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

Inicie o proxy de autenticação do Cloud SQL

Você pode iniciar o Cloud SQL Auth Proxy usando soquetes TCP ou a imagem Docker do Cloud SQL Auth Proxy. O binário do Cloud SQL Auth Proxy se conecta a uma ou mais instâncias do Cloud SQL especificadas na linha de comando e abre uma conexão local como um soquete TCP. Outros aplicativos e serviços, como o código do seu aplicativo ou as ferramentas de cliente de gerenciamento de banco de dados, podem se conectar às instâncias do Cloud SQL por meio dessa conexão de soquete 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

Conecte-se com o cliente sqlcmd

A string de conexão que você usa depende se você iniciou o Cloud SQL Auth Proxy usando um soquete TCP ou Docker.

Precisa de ajuda? Para obter ajuda na solução de problemas do proxy, consulte Solução de problemas de conexões do Cloud SQL Auth Proxy ou consulte nossa página de suporte do Cloud SQL .

Conectar com um aplicativo

Você pode se conectar ao Cloud SQL Auth Proxy a partir de qualquer linguagem que permita a conexão a um soquete TCP. Abaixo estão alguns trechos de código de exemplos completos no GitHub para ajudar você a entender como eles funcionam juntos em seu aplicativo.

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

Tópicos adicionais

Argumentos de linha de comando do Cloud SQL Auth Proxy

Os exemplos acima abrangem os casos de uso mais comuns, mas o Cloud SQL Auth Proxy também possui outras opções de configuração que podem ser definidas com argumentos de linha de comando. Para obter ajuda com argumentos de linha de comando, use a flag --help para visualizar a documentação mais recente:

./cloud-sql-proxy --help

Consulte o README no repositório GitHub do Cloud SQL Auth Proxy para obter exemplos adicionais de como usar as opções de linha de comando do Cloud SQL Auth Proxy.

Opções para autenticação do Cloud SQL Auth Proxy

Todas essas opções usam um INSTANCE_CONNECTION_NAME como string de conexão para identificar uma instância do Cloud SQL. Você pode encontrar o INSTANCE_CONNECTION_NAME na página "Visão Geral" da sua instância no Google Cloud console . ou executando o seguinte comando:

gcloud sql instances describe --project PROJECT_ID INSTANCE_CONNECTION_NAME .

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

Algumas dessas opções usam um arquivo de credenciais JSON que inclui a chave privada RSA da conta. Para obter instruções sobre como criar um arquivo de credenciais JSON para uma conta de serviço, consulte Criação de uma conta de serviço .

O Cloud SQL Auth Proxy oferece diversas alternativas de autenticação, dependendo do seu ambiente. O Cloud SQL Auth Proxy verifica cada um dos seguintes itens, na seguinte ordem, usando o primeiro que encontrar para tentar autenticar:

1. Credenciais fornecidas pelo sinalizador credentials-file.

   Use uma conta de serviço para criar e baixar o arquivo JSON associado e defina o sinalizador --credentials-file como o caminho do arquivo ao iniciar o Proxy de Autenticação do Cloud SQL. A conta de serviço deve ter as permissões necessárias para a instância do Cloud SQL.

   Para usar esta opção na linha de comando, invoque o comando cloud-sql-proxy com o sinalizador --credentials-file definido como o caminho e o nome de um arquivo de credencial JSON. O caminho pode ser absoluto ou relativo ao diretório de trabalho atual. Por exemplo:

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

   Para obter instruções detalhadas sobre como adicionar funções do IAM a uma conta de serviço, consulte Concessão de funções a contas de serviço .

   Para obter mais informações sobre as funções compatíveis com o Cloud SQL, consulte Funções do IAM para o Cloud SQL .

2. Credenciais fornecidas por um token de acesso.

   Crie um token de acesso e invoque o comando cloud-sql-proxy com o sinalizador --token definido como um token de acesso OAuth 2.0. Por exemplo:

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

3. Credenciais fornecidas por uma variável de ambiente.

   Esta opção é semelhante ao uso do sinalizador --credentials-file , exceto que você especifica o arquivo de credencial JSON definido na variável de ambiente GOOGLE_APPLICATION_CREDENTIALS em vez de usar o argumento de linha de comando --credentials-file .

4. Credenciais de um cliente gcloud CLI autenticado.

   Se você instalou a CLI do gcloud e se autenticou com sua conta pessoal, o Cloud SQL Auth Proxy poderá usar as mesmas credenciais da conta. Este método é especialmente útil para colocar um ambiente de desenvolvimento em funcionamento.

   Para permitir que o Cloud SQL Auth Proxy use suas credenciais do gcloud CLI, use o seguinte comando para autenticar o gcloud CLI:

   gcloud auth application-default login

5. Credenciais associadas à instância do Compute Engine.

   Se você estiver se conectando ao Cloud SQL a partir de uma instância do Compute Engine, o Proxy de Autenticação do Cloud SQL poderá usar a conta de serviço associada à instância do Compute Engine. Se a conta de serviço tiver as permissões necessárias para a instância do Cloud SQL, o Proxy de Autenticação do Cloud SQL será autenticado com sucesso.

   Se a instância do Compute Engine estiver no mesmo projeto que a instância do Cloud SQL, a conta de serviço padrão da instância do Compute Engine terá as permissões necessárias para autenticar o Proxy de Autenticação do Cloud SQL. Se as duas instâncias estiverem em projetos diferentes, você deverá adicionar a conta de serviço da instância do Compute Engine ao projeto que contém a instância do Cloud SQL.

6. Conta de serviço padrão do ambiente

   Se o Cloud SQL Auth Proxy não encontrar credenciais em nenhum dos locais abordados anteriormente, ele seguirá a lógica documentada em Configurando a Autenticação para Aplicativos de Produção de Servidor para Servidor . Alguns ambientes (como Compute Engine, App Engine e outros) fornecem uma conta de serviço padrão que seu aplicativo pode usar para autenticação por padrão. Se você usar uma conta de serviço padrão, ela deverá ter as permissões descritas em Funções e Permissões. Para obter mais informações sobre a abordagem do Google Cloud para autenticação, consulte Visão geral da autenticação .

Criar uma conta de serviço

1. No Google Cloud console, vá para a página Contas de serviço .

   Ir para contas de serviço

2. Selecione o projeto que contém sua instância do Cloud SQL.
3. Clique em Criar conta de serviço .
4. No campo Nome da conta de serviço , insira um nome descritivo para a conta de serviço.
5. Altere o ID da conta de serviço para um valor exclusivo e reconhecível e clique em Criar e continuar .
6. Clique no campo Selecionar uma função e selecione uma das seguintes funções:
   • Cloud SQL > Cliente Cloud SQL
   • Cloud SQL > Editor do Cloud SQL
   • Cloud SQL > Administração do Cloud SQL

7. Clique em Concluído para finalizar a criação da conta de serviço.
8. Clique no menu de ação da sua nova conta de serviço e selecione Gerenciar chaves .
9. Clique no menu suspenso Adicionar chave e depois clique em Criar nova chave .
10. Confirme se o tipo de chave é JSON e clique em Criar .

    O arquivo da chave privada será baixado para sua máquina. Você pode movê-lo para outro local. Mantenha o arquivo da chave seguro.

Use o Cloud SQL Auth Proxy com IP privado

Para se conectar a uma instância do Cloud SQL usando IP privado, o Cloud SQL Auth Proxy deve estar em um recurso com acesso à mesma rede VPC que a instância.

O Proxy de Autenticação do Cloud SQL usa IP para estabelecer uma conexão com sua instância do Cloud SQL. Por padrão, o Proxy de Autenticação do Cloud SQL tenta se conectar usando um endereço IPv4 público.

Se sua instância do Cloud SQL tiver apenas IP privado ou se a instância tiver IP público e privado configurados, e você quiser que o Cloud SQL Auth Proxy use o endereço IP privado, forneça a seguinte opção ao iniciar o Cloud SQL Auth Proxy:

--private-ip

Use o Cloud SQL Auth Proxy com instâncias que tenham o Private Service Connect habilitado

Você pode usar o Cloud SQL Auth Proxy para se conectar a uma instância do Cloud SQL com o Private Service Connect habilitado.

O Cloud SQL Auth Proxy é um conector que fornece acesso seguro a esta instância sem a necessidade de redes autorizadas ou de configuração de SSL.

Para permitir conexões de cliente do Proxy de Autenticação do Cloud SQL, você precisa configurar um registro DNS que corresponda ao nome DNS recomendado fornecido para a instância. O registro DNS é um mapeamento entre um recurso DNS e um nome de domínio.

Para obter mais informações sobre como usar o Cloud SQL Auth Proxy para se conectar a instâncias com o Private Service Connect habilitado, consulte Conectar usando o Cloud SQL Auth Proxy .

Execute o Cloud SQL Auth Proxy em um processo separado

Executar o Proxy de Autenticação do Cloud SQL em um processo de terminal separado do Cloud Shell pode ser útil para evitar misturar a saída do console com a saída de outros programas. Use a sintaxe abaixo para invocar o Proxy de Autenticação do Cloud SQL em um processo separado.

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

Execute o Cloud SQL Auth Proxy em um contêiner do Docker

Para executar o Cloud SQL Auth Proxy em um contêiner do Docker, use a imagem do Docker do Cloud SQL Auth Proxy disponível no Google Container Registry . Você pode instalar a imagem do Docker do Cloud SQL Auth Proxy usando o seguinte comando:

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

Você pode iniciar o Cloud SQL Auth Proxy usando soquetes TCP ou Unix, com os comandos mostrados abaixo.

    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

Se você estiver usando uma imagem otimizada para contêiner, use um diretório gravável no lugar de /cloudsql , por exemplo:

v /mnt/stateful_partition/cloudsql:/cloudsql

Se você estiver usando as credenciais fornecidas pela sua instância do Compute Engine, não inclua o parâmetro credential_file e a linha -v PATH_TO_KEY_FILE :/path/to/service-account-key.json .

Executando o Cloud SQL Auth Proxy como um serviço

Executar o Cloud SQL Auth Proxy como um serviço em segundo plano é uma opção para cargas de trabalho de desenvolvimento e produção locais. Em desenvolvimento, quando você precisa acessar sua instância do Cloud SQL, pode iniciar o serviço em segundo plano e interrompê-lo ao concluir.

Para cargas de trabalho de produção, o Cloud SQL Auth Proxy não oferece suporte integrado para execução como um serviço do Windows, mas gerenciadores de serviços de terceiros podem ser usados ​​para executá-lo como um serviço. Por exemplo, você pode usar o NSSM para configurar o Cloud SQL Auth Proxy como um serviço do Windows, e o NSSM monitora o Cloud SQL Auth Proxy e o reinicia automaticamente se ele parar de responder. Consulte a documentação do NSSM para obter mais informações.

Conecte quando SSL for necessário

Aplicar o uso do Cloud SQL Auth Proxy

Habilite o uso do Cloud SQL Auth Proxy no Cloud SQL usando ConnectorEnforcement .

Se você estiver usando uma instância habilitada para Private Service Connect , haverá uma limitação. Se a instância tiver a imposição do conector habilitada, não será possível criar réplicas de leitura para ela. Da mesma forma, se a instância tiver réplicas de leitura, não será possível habilitar a imposição do conector para ela.

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

Dicas para trabalhar com o Cloud SQL Auth Proxy

Use o Cloud SQL Auth Proxy para se conectar a várias instâncias

Você pode usar um cliente proxy de autenticação local do Cloud SQL para se conectar a várias instâncias do Cloud SQL. A maneira como você faz isso depende se você está usando soquetes Unix ou 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 conexões do Cloud SQL Auth Proxy

A imagem do Docker do Cloud SQL Auth Proxy é baseada em uma versão específica do Cloud SQL Auth Proxy. Quando uma nova versão do Cloud SQL Auth Proxy estiver disponível, extraia a nova versão da imagem do Docker do Cloud SQL Auth Proxy para manter seu ambiente atualizado. Você pode ver a versão atual do Cloud SQL Auth Proxy consultando a página de lançamentos do Cloud SQL Auth Proxy no GitHub .

Se você estiver tendo problemas para se conectar à sua instância do Cloud SQL usando o Cloud SQL Auth Proxy, aqui estão algumas coisas que você pode tentar fazer para descobrir a causa do problema.

• Verifique se você está usando o endereço IP para se conectar à instância, e não o ponto de extremidade de gravação .

• Verifique a saída do Cloud SQL Auth Proxy.

  Muitas vezes, a saída do Proxy de Autenticação do Cloud SQL pode ajudar a determinar a origem do problema e como resolvê-lo. Envie a saída para um arquivo ou observe o terminal do Cloud Shell onde você iniciou o Proxy de Autenticação do Cloud SQL.

• Se você estiver recebendo um erro 403 notAuthorized e estiver usando uma conta de serviço para autenticar o Cloud SQL Auth Proxy, verifique se a conta de serviço tem as permissões corretas.

  Você pode verificar a conta de serviço pesquisando seu ID na página do IAM . Ela deve ter a permissão cloudsql.instances.connect . As funções predefinidas Cloud SQL Admin , Client e Editor do Cloud SQL têm essa permissão.

• Se você estiver se conectando pelo App Engine e receber o erro 403 notAuthorized , verifique o valor cloud_sql_instances app.yaml para ver se há um nome de conexão de instância incorreto ou com erro de ortografia. Os nomes de conexão de instância estão sempre no formato PROJECT:REGION:INSTANCE .

  Além disso, verifique se a conta de serviço do App Engine (por exemplo, [email protected]) tem a função IAM do cliente Cloud SQL.

  Se o serviço do App Engine residir em um projeto (projeto A) e o banco de dados residir em outro (projeto B), esse erro significa que a conta de serviço do App Engine não recebeu a função IAM do cliente do Cloud SQL no projeto com o banco de dados (projeto B).

• Certifique-se de habilitar a API de administração do Cloud SQL.

  Caso contrário, você verá uma saída como Error 403: Access Not Configured nos seus logs do Cloud SQL Auth Proxy.

• Se você estiver incluindo várias instâncias na sua lista de instâncias, certifique-se de usar uma vírgula como delimitador, sem espaços. Se estiver usando TCP, certifique-se de especificar portas diferentes para cada instância.

• Se você estiver se conectando usando soquetes UNIX, confirme se os soquetes foram criados listando o diretório fornecido quando iniciou o Cloud SQL Auth Proxy.

• Se você tiver uma política de firewall de saída, certifique-se de que ela permita conexões à porta 3307 na instância de destino do Cloud SQL.

• Você pode confirmar se o Cloud SQL Auth Proxy foi iniciado corretamente observando os logs na seção Operações > Registro > Explorador de logs doGoogle Cloud console. Uma operação bem-sucedida se parece com o seguinte:

  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 cota: quando a cota da API de administração do Cloud SQL é violada, o Cloud SQL Auth Proxy é iniciado com a seguinte mensagem de erro:

  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
  

  Quando um aplicativo se conecta ao proxy, o proxy relata o seguinte erro:

  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
  

  Solução: Identifique a origem do problema de cota (por exemplo, um aplicativo está usando o conector incorretamente e criando novas conexões desnecessariamente) ou entre em contato com o suporte para solicitar um aumento na cota da API de administração do Cloud SQL. Se o erro de cota aparecer na inicialização, você deverá reimplantar o aplicativo para reiniciar o proxy. Se o erro de cota aparecer após a inicialização, a reimplantação não será necessária.

O que vem a seguir

• Saiba mais sobre o Cloud SQL Auth Proxy .
• Saiba mais sobre Gerenciamento de Identidade e Acesso (IAM) .
• Saiba mais sobre contas de serviço .
• Saiba mais sobre os dois níveis de controle de acesso para instâncias do Cloud SQL.
• Crie usuários e bancos de dados .
• Saiba mais sobre como se conectar à sua instância a partir do seu aplicativo .
• Saiba mais sobre opções de suporte .