Accesso a un database con l'autenticazione IAM dei database

Questa pagina descrive in che modo gli utenti e gli account di servizio possono accedere a Cloud SQL utilizzando l'autenticazione IAM dei database Cloud SQL. Per ulteriori informazioni, vedi Autenticazione IAM.

Prima di iniziare

  • Configura l'istanza in modo che utilizzi l'autenticazione del database IAM. Per ulteriori informazioni, vedi Configura nuove istanze per l'autenticazione IAM dei database.
  • Aggiungi un utente IAM, un account di servizio o un gruppo nel database. Per maggiori informazioni le informazioni, vedi Aggiungi un account utente o di servizio IAM al database e Aggiungi un gruppo al database.
  • Aggiungere il ruolo IAM roles/cloudsql.instanceUser a il tuo utente IAM, gruppo o account di servizio. Si tratta di un ruolo predefinito che contiene le risorse IAM di Cloud SQL necessarie Autorizzazione cloudsql.instances.login. Devi disporre di questa autorizzazione per accedere a un'istanza di database con autenticazione IAM. Per ulteriori informazioni, consulta Ruoli e autorizzazioni.

  • Quando un utente IAM viene aggiunto a un database, il nuovo utente del database non dispone di privilegi a qualsiasi database per impostazione predefinita. Devi usa il comando GRANT per fornire all'utente del database IAM tutte le richieste autorizzazioni aggiuntive. Per ulteriori informazioni, consulta Concedere i privilegi di database all'utente IAM e Concedi i privilegi di database a un gruppo.

  • Se utilizzi l'autenticazione di gruppo IAM, l'utente IAM o account di servizio deve essere membro di un gruppo a cui è stato concesso un Ruolo o autorizzazioni IAM per accedere all'istanza Cloud SQL. Cloud SQL crea un account dopo che l'account utente o di servizio ha eseguito l'accesso all'istanza per la prima volta.

Accedi con l'autenticazione automatica del database IAM

Puoi configurare un connettore Cloud SQL per gestire automaticamente all'istanza Cloud SQL per conto di un utente o un'applicazione. I connettori includono il proxy di autenticazione Cloud SQL, il connettore Go, il Java e il connettore Connettore Python, che supportano tutti l'autenticazione automatica del database IAM. Se utilizzi un il connettore Cloud SQL con Autenticazione del database IAM: l'account IAM che utilizzi per avviare il connettore. deve essere lo stesso account che esegue l'autenticazione nel database.

Per accedere utilizzando l'autenticazione automatica del database IAM:

Proxy di autenticazione Cloud SQL

  1. Autenticazione in Google Cloud.

    User

    Esegui l'autenticazione in Google Cloud utilizzando le credenziali predefinite dell'applicazione (ADC).

    Utilizza la gcloud auth application-default login . Per ulteriori informazioni, vedi Configura Credenziali predefinite dell'applicazione.

    Account di servizio

    Per eseguire l'autenticazione in Google Cloud utilizzando ADC con un account di servizio, devi puoi utilizzare la simulazione dell'identità degli account di servizio o configurare una chiave dell'account di servizio. Se vuoi eseguire l'autenticazione con la simulazione dell'identità degli account di servizio, sostituisci SERVICE_ACCOUNT_EMAIL_ADDRESS ed esegui questo comando:

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

    Per ulteriori informazioni, vedi Configura Credenziali predefinite dell'applicazione.

  2. Avvia il proxy di autenticazione Cloud SQL con il flag --auto-iam-authn Sostituisci INSTANCE_CONNECTION_NAME con la stringa di connessione utilizzato per identificare l'istanza Cloud SQL. Se utilizzi una porta diversa da quella predefinita MySQL, specifica il numero di porta. Per ulteriori informazioni come trovare e costruire questa stringa, consulta Opzioni per l'autenticazione del proxy di autenticazione Cloud SQL.

    ./cloud-sql-proxy --auto-iam-authn INSTANCE_CONNECTION_NAME

    Per ulteriori informazioni su come avviare il proxy, consulta Avvia il proxy di autenticazione Cloud SQL.

  3. Quando è tutto pronto per connetterti all'istanza utilizzando il proxy di autenticazione Cloud SQL, accedi con il client mysql. Sostituisci quanto segue:

    • HOSTNAME: indirizzo IP utilizzato dal proxy di autenticazione Cloud SQL. Per impostazione predefinita, il proxy di autenticazione Cloud SQL utilizza l'indirizzo localhost di 127.0.0.1, ma puoi e assegnare un indirizzo IP diverso all'avvio del proxy di autenticazione Cloud SQL.
    • USERNAME: per un account utente IAM, questo è l'indirizzo email dell'utente, senza il simbolo @ o un nome di dominio. Ad esempio, per test-user@example.com, inserisci test-user. Per un account di servizio, si tratta del servizio all'indirizzo email dell'account senza Suffisso @project-id.iam.gserviceaccount.com.
    • PORT_NUMBER: facoltativo. Se hai specificato una porta diversa nella stringa di connessione dell'istanza, quindi specifica il numero di porta.

    Esegui questo comando:

    mysql --host=HOSTNAME \
--user=USERNAME \
--port=PORT_NUMBER

    Per saperne di più su come connetterti al proxy di autenticazione Cloud SQL, consulta Connettiti al client mysql.

Vai 

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

	"cloud.google.com/go/cloudsqlconn"
	"github.com/go-sql-driver/mysql"
)

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'
		dbName                 = mustGetenv("DB_NAME")                  // e.g. 'my-database'
		instanceConnectionName = mustGetenv("INSTANCE_CONNECTION_NAME") // e.g. 'project:region:instance'
		usePrivate             = os.Getenv("PRIVATE_IP")
	)

	d, err := cloudsqlconn.NewDialer(context.Background(), cloudsqlconn.WithIAMAuthN())
	if err != nil {
		return nil, fmt.Errorf("cloudsqlconn.NewDialer: %w", err)
	}
	var opts []cloudsqlconn.DialOption
	if usePrivate != "" {
		opts = append(opts, cloudsqlconn.WithPrivateIP())
	}
	mysql.RegisterDialContext("cloudsqlconn",
		func(ctx context.Context, addr string) (net.Conn, error) {
			return d.Dial(ctx, instanceConnectionName, opts...)
		})

	dbURI := fmt.Sprintf("%s:empty@cloudsqlconn(localhost:3306)/%s?parseTime=true",
		dbUser, dbName)

	dbPool, err := sql.Open("mysql", dbURI)
	if err != nil {
		return nil, fmt.Errorf("sql.Open: %w", err)
	}
	return dbPool, nil
}

JDBC Java 

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 INSTANCE_UNIX_SOCKET = System.getenv("INSTANCE_UNIX_SOCKET");
  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:mysql:///<DB_NAME>?cloudSqlInstance=<INSTANCE_CONNECTION_NAME>&
    // socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=<DB_USER>&password=<DB_PASS>
    // 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 user to connect with.
    config.setJdbcUrl(String.format("jdbc:mysql:///%s", DB_NAME));

    config.addDataSourceProperty("socketFactory", "com.google.cloud.sql.mysql.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);
    // 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");


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

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

R2DBC Java 

// Set up ConnectionFactoryOptions
ConnectionFactoryOptions options =
    ConnectionFactoryOptions.builder()
        .option(DRIVER, "gcp")
        .option(PROTOCOL, "mysql")
        .option(USER, DB_USER)
        .option(DATABASE, DB_NAME)
        .option(HOST, CONNECTION_NAME)
        .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 pymysql

import sqlalchemy


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

    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. 'service-account-name'
    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()

    def getconn() -> pymysql.connections.Connection:
        conn: pymysql.connections.Connection = connector.connect(
            instance_connection_name,
            "pymysql",
            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(
        "mysql+pymysql://",
        creator=getconn,
        # ...
    )
    return pool

Accedi con l'autenticazione manuale del database IAM

Un utente o un'applicazione possono eseguire l'autenticazione nel database utilizzando IAM richiedendo manualmente un token di accesso a Google Cloud e presentandolo del database. Con gcloud CLI, puoi richiedere esplicitamente un OAuth 2.0 con il token Ambito dell'API Cloud SQL Admin utilizzato per accedere al database. Quando accedi come utente del database con autenticazione IAM manuale del database, utilizzerai il tuo indirizzo email come nome utente e il token di accesso come password. Puoi utilizzare questo metodo con un'implementazione al database o con un connettore Cloud SQL.

In questa procedura, esegui l'autenticazione in Google Cloud, richiedi un token di accesso, e poi connetterti al database passando il token come password l'utente del database IAM. Segui questa procedura per connetterti senza il proxy di autenticazione Cloud SQL.

Per questi passaggi, devi:

Per accedere utilizzando l'autenticazione manuale del database IAM:

gcloud

  1. Autenticazione in Google Cloud.

    User

    Esegui l'autenticazione in IAM utilizzando gcloud auth login Per maggiori informazioni le informazioni, vedi Autorizzare con un account utente.

    Account di servizio

    Esegui l'autenticazione in IAM utilizzando gcloud auth activate-service-account Per ulteriori informazioni, vedi Autorizza con un account di servizio.

  2. Richiedi il token di accesso e accedi con un client.

    Sostituisci quanto segue:

    • HOSTNAME: l'indirizzo IP dell'istanza, ovvero l'indirizzo IP pubblico Indirizzo IP o indirizzo IP privato.
    • USERNAME: per un account utente IAM, questa è la l'indirizzo email dell'utente, senza il simbolo @ o il nome di dominio. Ad esempio, per test-user@example.com, inserisci test-user. Per un account di servizio, si tratta del servizio all'indirizzo email dell'account senza Suffisso @project-id.iam.gserviceaccount.com. 

     MYSQL_PWD=`gcloud sql generate-login-token` \
 mysql --enable-cleartext-plugin \
 --ssl-mode=REQUIRED \
 --host=HOSTNAME \
 --user=USERNAME

    Se ssl_mode sull'istanza Cloud SQL sia configurata TRUSTED_CLIENT_CERTIFICATE_REQUIRED, includi un certificato client e una chiave client quando se ne hai già uno. Inoltre, per consentire al client di verificare la proprietà identità per l'autenticazione reciproca, specifica il server certificato server-ca.pem. Ad esempio:

     MYSQL_PWD=`gcloud sql generate-login-token` \
 mysql --enable-cleartext-plugin \
 --ssl-mode=VERIFY_CA \
 --ssl-ca=server-ca.pem \
 --ssl-cert=client-cert.pem \
 --ssl-key=client-key.pem \
 --host=HOSTNAME \
 --user=USERNAME

    Per informazioni su come creare un certificato e una chiave client, consulta Certificati client.

Passaggi successivi