Inicie sessão através da autenticação da base de dados de IAM

Esta página descreve como os utilizadores e as contas de serviço podem iniciar sessão em bases de dados do Cloud SQL através da autenticação de base de dados do Cloud SQL IAM. Para mais informações, consulte o artigo Autenticação da IAM.

Antes de começar

  • Configure a instância para usar a autenticação da base de dados da IAM. Para mais informações, consulte o artigo Configure novas instâncias para a autenticação da base de dados da IAM.
  • Adicione um utilizador, uma conta de serviço ou um grupo do IAM à base de dados. Para mais informações, consulte Adicione um utilizador ou uma conta de serviço do IAM à base de dados e Adicione um grupo à base de dados.
  • Adicione a função de IAM roles/cloudsql.instanceUser ao seu utilizador de IAM, conta de serviço ou grupo. É uma função predefinida que contém a autorização de IAM do Cloud SQL cloudsql.instances.login necessária. Precisa desta autorização para iniciar sessão numa instância da base de dados com a autenticação da base de dados do IAM. Para mais informações, consulte o artigo Funções e autorizações.
  • Se estiver a usar o proxy de autorização do Cloud SQL, adicione a função de roles/cloudsql.client IAM ao seu utilizador, conta de serviço ou grupo do IAM. É uma função predefinida que contém a autorização de IAM cloudsql.instances.connect do Cloud SQL necessária. Precisa desta autorização para iniciar sessão numa instância da base de dados com o proxy Auth do Cloud SQL. Para mais informações, consulte o artigo Funções e autorizações.

  • Quando um utilizador do IAM é adicionado a uma base de dados, o novo utilizador da base de dados não tem privilégios em nenhuma base de dados por predefinição. Tem de usar o comando GRANT para conceder ao utilizador da base de dados do IAM as autorizações necessárias. Para mais informações, consulte os artigos Conceda privilégios de base de dados ao utilizador do IAM e Conceda privilégios de base de dados a um grupo.

  • Se estiver a usar a autenticação de grupo do IAM, o utilizador do IAM ou a conta de serviço tem de ser membro de um grupo ao qual foi concedida uma função ou autorizações do IAM para iniciar sessão na instância do Cloud SQL. O Cloud SQL cria uma conta depois de o utilizador ou a conta de serviço iniciar sessão na instância pela primeira vez.

Inicie sessão com a autenticação automática da base de dados do IAM

Pode configurar um conetor do Cloud SQL para processar automaticamente a autenticação na instância do Cloud SQL em nome de um utilizador ou de uma aplicação. Os conetores incluem o proxy Auth do Cloud SQL, o conetor Go, o conetor Java e o conetor Python, que suportam a autenticação automática da base de dados da IAM. Quando usar um conetor do Cloud SQL com a autenticação de base de dados do IAM automática, a conta do IAM que usa para iniciar o conetor tem de ser a mesma conta que autentica a base de dados.

Para iniciar sessão através da autenticação automática da base de dados do IAM:

Proxy Auth do Cloud SQL

  1. Autentique-se em Google Cloud.

    Utilizador

    Autentique-se no Google Cloud com as Credenciais padrão da aplicação (ADC).

    Use o comando gcloud auth application-default login. Para mais informações, consulte o artigo Configure as Credenciais padrão da aplicação.

    Conta de serviço

    Para fazer a autenticação no Google Cloud com o ADC e uma conta de serviço, pode usar a simulação da conta de serviço ou uma chave da conta de serviço. Para usar a representação da conta de serviço, substitua SERVICE_ACCOUNT_EMAIL_ADDRESS e execute o seguinte comando:

    gcloud auth application-default login --impersonate-service-account SERVICE_ACCOUNT_EMAIL_ADDRESS

    Para mais informações, consulte o artigo Configure as Credenciais padrão da aplicação.

  2. Inicie o proxy Auth do Cloud SQL com a flag --auto-iam-authn.

    Substitua o seguinte:

    • INSTANCE_CONNECTION_NAME: a string de ligação para identificar uma instância do Cloud SQL. Se usar uma porta diferente da porta predefinida do PostgreSQL, especifique o número da porta. Para mais informações sobre como encontrar e criar esta string, consulte as Opções para autenticar o proxy Auth do Cloud SQL.
    ./cloud-sql-proxy --auto-iam-authn INSTANCE_CONNECTION_NAME

    Para mais informações sobre como iniciar o proxy, consulte o artigo Inicie o proxy Auth do Cloud SQL.

  3. Quando estiver pronto para estabelecer ligação à instância através do proxy Auth do Cloud SQL, inicie sessão com o cliente psql.

    Substitua o seguinte:

    • HOSTNAME: endereço IP usado pelo proxy Auth do Cloud SQL. Por predefinição, o proxy Auth do Cloud SQL usa o endereço de localhost de 127.0.0.1, mas pode atribuir um endereço IP diferente quando inicia o proxy Auth do Cloud SQL.
    • USERNAME: para um IAM, o nome de utilizador é o endereço de email completo do utilizador. Para uma conta de serviço, trata-se do email da conta de serviço sem o sufixo do domínio..gserviceaccount.com
    • PORT_NUMBER: opcional. Se especificou uma porta diferente na string de ligação da instância, especifique esse número da porta.
    • DATABASE_NAME: o nome da base de dados à qual estabelecer ligação.

    Execute o seguinte comando:

    psql -h HOSTNAME \
 -U USERNAME \
 --port PORT_NUMBER \
 --dbname=DATABASE_NAME

    Para mais informações sobre como estabelecer ligação ao proxy Auth do Cloud SQL, consulte o artigo Estabeleça ligação com o cliente psql.

Ir 

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"net"
	"os"

	"cloud.google.com/go/cloudsqlconn"
	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/stdlib"
)

func connectWithConnectorIAMAuthN() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Warning: %s environment variable not set.", 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_IAM_USER")              // e.g. 'service-account-name@project-id.iam'
		dbName                 = mustGetenv("DB_NAME")                  // e.g. 'my-database'
		instanceConnectionName = mustGetenv("INSTANCE_CONNECTION_NAME") // e.g. 'project:region:instance'
		usePrivate             = os.Getenv("PRIVATE_IP")
	)

	// WithLazyRefresh() Option is used to perform refresh
	// when needed, rather than on a scheduled interval.
	// This is recommended for serverless environments to
	// avoid background refreshes from throttling CPU.
	d, err := cloudsqlconn.NewDialer(
		context.Background(),
		cloudsqlconn.WithIAMAuthN(),
		cloudsqlconn.WithLazyRefresh(),
	)
	if err != nil {
		return nil, fmt.Errorf("cloudsqlconn.NewDialer: %w", err)
	}
	var opts []cloudsqlconn.DialOption
	if usePrivate != "" {
		opts = append(opts, cloudsqlconn.WithPrivateIP())
	}

	dsn := fmt.Sprintf("user=%s database=%s", dbUser, dbName)
	config, err := pgx.ParseConfig(dsn)
	if err != nil {
		return nil, err
	}

	config.DialFunc = func(ctx context.Context, network, instance string) (net.Conn, error) {
		return d.Dial(ctx, instanceConnectionName, opts...)
	}
	dbURI := stdlib.RegisterConnConfig(config)
	dbPool, err := sql.Open("pgx", dbURI)
	if err != nil {
		return nil, fmt.Errorf("sql.Open: %w", err)
	}
	return dbPool, nil
}

Java JDBC 

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

public class ConnectorIamAuthnConnectionPoolFactory 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 INSTANCE_CONNECTION_NAME =
      System.getenv("INSTANCE_CONNECTION_NAME");
  private static final String DB_IAM_USER = System.getenv("DB_IAM_USER");
  private static final String DB_NAME = System.getenv("DB_NAME");

  public static DataSource createConnectionPool() {
    // The configuration object specifies behaviors for the connection pool.
    HikariConfig config = new HikariConfig();

    // The following URL is equivalent to setting the config options below:
    // jdbc:postgresql:///<DB_NAME>?cloudSqlInstance=<INSTANCE_CONNECTION_NAME>&
    // socketFactory=com.google.cloud.sql.postgres.SocketFactory&user=<DB_IAM_USER>&
    // password=password
    // See the link below for more info on building a JDBC URL for the Cloud SQL JDBC Socket Factory
    // https://github.com/GoogleCloudPlatform/cloud-sql-jdbc-socket-factory#creating-the-jdbc-url

    // Configure which instance and what database to connect with.
    config.setJdbcUrl(String.format("jdbc:postgresql:///%s", DB_NAME));

    config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.postgres.SocketFactory");
    config.addDataSourceProperty("cloudSqlInstance", INSTANCE_CONNECTION_NAME);

    // If connecting using automatic database authentication, follow the instructions for
    // connecting using the connector, but set the DB_IAM_USER value to an IAM user or
    // service account that has been given access to the database.
    // See https://cloud.google.com/sql/docs/postgres/iam-logins for more details.
    config.addDataSourceProperty("enableIamAuth", "true");
    config.addDataSourceProperty("user", DB_IAM_USER);
    // Password must be set to a nonempty value to bypass driver validation errors.
    config.addDataSourceProperty("password", "password");
    // Explicitly set sslmode to disable to prevent driver from hanging.
    // The Java Connector will handle SSL so it is unneccesary to enable it at the driver level.
    config.addDataSourceProperty("sslmode", "disable");

    // cloudSqlRefreshStrategy set to "lazy" is used to perform a
    // refresh when needed, rather than on a scheduled interval.
    // This is recommended for serverless environments to
    // avoid background refreshes from throttling CPU.
    config.addDataSourceProperty("cloudSqlRefreshStrategy", "lazy");

    // ... Specify additional connection properties here.
    // ...

    // Initialize the connection pool using the configuration object.
    return new HikariDataSource(config);
  }
}

Java R2DBC 

private static final String CONNECTION_NAME = System.getenv("POSTGRES_CONNECTION_NAME");
private static final String DB_NAME = System.getenv("POSTGRES_DB");
private static final String DB_USER = System.getenv("POSTGRES_IAM_USER");
private static final String IP_TYPE =
    System.getenv("IP_TYPE") == null ? "PUBLIC" : System.getenv("IP_TYPE");
  // Set up ConnectionFactoryOptions
  ConnectionFactoryOptions options =
      ConnectionFactoryOptions.builder()
          .option(DRIVER, "gcp")
          .option(PROTOCOL, "postgresql")
          // Password must be set to a nonempty value to bypass driver validation errors
          .option(PASSWORD, "password")
          .option(USER, DB_USER)
          .option(DATABASE, DB_NAME)
          .option(HOST, CONNECTION_NAME)
          .option(IP_TYPES, IP_TYPE)
          .option(ENABLE_IAM_AUTH, true)
          .build();

  // Initialize connection pool
  ConnectionFactory connectionFactory = ConnectionFactories.get(options);
  ConnectionPoolConfiguration configuration =
      ConnectionPoolConfiguration.builder(connectionFactory).build();

  this.connectionPool = new ConnectionPool(configuration);

Python 

import os

from google.cloud.sql.connector import Connector, IPTypes
import pg8000

import sqlalchemy


def connect_with_connector_auto_iam_authn() -> sqlalchemy.engine.base.Engine:
    """
    Initializes a connection pool for a Cloud SQL instance of Postgres.

    Uses the Cloud SQL Python Connector with Automatic IAM Database Authentication.
    """
    # 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.
    instance_connection_name = os.environ[
        "INSTANCE_CONNECTION_NAME"
    ]  # e.g. 'project:region:instance'
    db_iam_user = os.environ["DB_IAM_USER"]  # e.g. 'sa-name@project-id.iam'
    db_name = os.environ["DB_NAME"]  # e.g. 'my-database'

    ip_type = IPTypes.PRIVATE if os.environ.get("PRIVATE_IP") else IPTypes.PUBLIC

    # initialize Cloud SQL Python Connector object
    connector = Connector(refresh_strategy="LAZY")

    def getconn() -> pg8000.dbapi.Connection:
        conn: pg8000.dbapi.Connection = connector.connect(
            instance_connection_name,
            "pg8000",
            user=db_iam_user,
            db=db_name,
            enable_iam_auth=True,
            ip_type=ip_type,
        )
        return conn

    # The Cloud SQL Python Connector can be used with SQLAlchemy
    # using the 'creator' argument to 'create_engine'
    pool = sqlalchemy.create_engine(
        "postgresql+pg8000://",
        creator=getconn,
        # ...
    )
    return pool

Inicie sessão com a autenticação manual da base de dados IAM

Um utilizador ou uma aplicação pode autenticar-se na base de dados através do IAM pedindo manualmente um token de acesso a Google Cloud e apresentando-o à base de dados. Com a CLI gcloud, pode pedir explicitamente um token OAuth 2.0 com o âmbito da API Cloud SQL Admin que é usado para iniciar sessão na base de dados. Quando inicia sessão como um utilizador da base de dados com a autenticação manual da base de dados do IAM, usa o seu endereço de email como nome de utilizador e o token de acesso como palavra-passe. Pode usar este método com uma ligação direta à base de dados ou com um conetor do Cloud SQL.

Neste procedimento, autentica-se no Google Cloud, pede um token de acesso e, em seguida, liga-se à base de dados transmitindo o token como a palavra-passe do utilizador da base de dados do IAM. Use estes passos para estabelecer ligação sem o proxy Auth do Cloud SQL.

Para estes passos, tem de:

  • Se estiver a estabelecer ligação a uma instância com um IP público, autorize o acesso externo à instância. Para mais informações, consulte o artigo Autorize o endereço IP da sua máquina para IP público.
  • Se estiver a ligar-se a uma instância com um IP privado, execute o comando na rede da nuvem virtual privada (VPC).
  • Use o comando gcloud sql generate-login-token para gerar o seu token de autenticação.

    • Para iniciar sessão através da autenticação manual da base de dados de IAM:

    gcloud

    1. Autentique-se em Google Cloud.

      Utilizador

      Faça a autenticação no IAM através de gcloud auth login. Para mais informações, consulte o artigo Autorize com uma conta de utilizador.

      Conta de serviço

      Faça a autenticação no IAM através de gcloud auth activate-service-account. Para mais informações, consulte o artigo Autorize com uma conta de serviço.

    2. Peça o token de acesso e inicie sessão com um cliente.

      Substitua o seguinte:

      • HOSTNAME: O endereço IP da instância, o endereço IP público ou o endereço IP privado.
      • USERNAME: para um IAM, o nome de utilizador é o endereço de email completo do utilizador. Para uma conta de serviço, trata-se do email da conta de serviço sem o sufixo do domínio..gserviceaccount.com
      • DATABASE_NAME: o nome da base de dados à qual estabelecer ligação. 

       PGPASSWORD=`gcloud sql generate-login-token` \
 psql "sslmode=require \
 hostaddr=HOSTNAME \
 user=USERNAME \
 dbname=DATABASE_NAME" \
 --no-password

      Se a ssl_mode na sua instância do Cloud SQL estiver configurada para TRUSTED_CLIENT_CERTIFICATE_REQUIRED, recomendamos que inicie sessão com a autenticação automática da base de dados do IAM para aplicar a validação da identidade do cliente.

    O que se segue?