Integra il supporto dei gruppi Active Directory con AlloyDB Omni

Seleziona una versione della documentazione:

Questa pagina descrive come configurare e gestire l'autenticazione e l'autorizzazione basate su gruppi di Active Directory in AlloyDB Omni. Il supporto basato sui gruppi di Active Directory automatizza la gestione delle appartenenze ai ruoli PostgreSQL in base alle appartenenze ai gruppi di un utente in Active Directory, il che semplifica la gestione degli utenti e garantisce la sincronizzazione delle autorizzazioni.

Per ulteriori informazioni, vedi Panoramica di Active Directory.

Workflow di integrazione di Active Directory

L'integrazione di Active Directory viene implementata utilizzando un'estensione PostgreSQL (google_pg_auth) come mostrato nel seguente flusso di lavoro:

  1. Accesso utente: un utente si autentica su AlloyDB Omni utilizzando le proprie credenziali standard di Active Directory tramite GSSAPI.
  2. Creazione automatica dei ruoli: se non esiste un ruolo PostgreSQL corrispondente per l'utente, il sistema ne crea automaticamente uno, ad esempio CREATE ROLE "user@REALM" WITH LOGIN;.
  3. Controllo dei gruppi LDAP: il sistema si connette in modo sicuro ad Active Directory utilizzando LDAP per recuperare le appartenenze ai gruppi correnti dell'utente.
  4. Sincronizzazione dell'appartenenza: il sistema confronta i gruppi Active Directory dell'utente con i mapping che hai configurato.
    • Se l'utente si trova in un gruppo Active Directory mappato, ma non nel gruppo PostgreSQL corrispondente, gli viene concessa l'iscrizione.
    • Se l'utente non fa parte di un gruppo Active Directory mappato, ma fa parte del gruppo PostgreSQL corrispondente, l'appartenenza dell'utente viene revocata.
  5. Accesso completato: la connessione dell'utente è finalizzata e l'utente ha eseguito l'accesso al database. Le autorizzazioni dell'utente sono determinate dai ruoli PostgreSQL a cui appartiene, che sono sincronizzati con lo stato del gruppo Active Directory.

Questa sincronizzazione avviene automaticamente a ogni accesso dell'utente, il che garantisce che i diritti di accesso a PostgreSQL riflettano lo stato attuale di Active Directory.

Prima di iniziare

Prima di integrare il supporto dei gruppi Active Directory con AlloyDB Omni, assicurati di soddisfare i seguenti requisiti.

  • Autenticazione GSSAPI: l'autenticazione basata su GSSAPI deve essere configurata e operativa per l'istanza AlloyDB Omni. Per saperne di più, consulta Integrare Active Directory con AlloyDB Omni.

  • Ruoli di gruppo PostgreSQL: devi creare manualmente i ruoli di gruppo PostgreSQL che intendi mappare ai gruppi Active Directory, come mostrato nell'esempio seguente:

    CREATE ROLE 'postgres_developers';
CREATE ROLE 'postgres_read_only';

  • Autorizzazioni: devi assegnare manualmente le autorizzazioni del database, ad esempio SELECT e INSERT, a questi ruoli di gruppo PostgreSQL. L'integrazione gestisce solo l'appartenenza, ma non i privilegi dei gruppi stessi, come mostrato nell'esempio seguente:

    GRANT SELECT ON ALL TABLES IN SCHEMA sales TO postgres_read_only;
GRANT USAGE ON SCHEMA finance TO postgres_developers;
GRANT USAGE ON SCHEMA sales TO postgres_read_only;
GRANT SELECT, INSERT ON finance.transactions TO postgres_developers;

Configurare il supporto dei gruppi Active Directory

Per configurare il supporto dei gruppi Active Directory in AlloyDB Omni, devi attivare l'estensione google_pg_auth, fornire i dettagli di Active Directory nel file postgresql.conf e gestire le credenziali in modo sicuro.

  1. Fornisci la password LDAP.

    Devi fornire la password per l'account di servizio ldap_bind_dn al container AlloyDB Omni utilizzando la variabile di ambiente AD_LDAP_PASSWORD, come mostrato nell'esempio seguente:

    docker run -d --name CONTAINER_NAME \
          -e POSTGRES_PASSWORD=NEW_PASSWORD \
          -e AD_LDAP_PASSWORD=AD_LDAP_PASSWORD \
          -vDATA_DIR:/var/lib/postgresql/data \
          -p HOST_PORT:5432 \
          --restart=always \
          google/alloydbomni:IMAGE_TAG

  2. Attiva l'estensione google_pg_auth.

    1. Nel file postgresql.conf, aggiungi o modifica i seguenti parametri per attivare l'estensione e configurare la connessione LDAP. Il file postgresql.conf si trova nella directory dei dati che hai montato all'avvio dell'immagine AlloyDB Omni.

      # ---------------------------------------------------------------------------
# ALLOYDB ACTIVE DIRECTORY INTEGRATION SETTINGS
# ---------------------------------------------------------------------------

google_pg_auth.enable_auth = on
google_pg_auth.ldap_uri = "AD_LDAP_SERVER_HOST"
google_pg_auth.ldap_base_dn = AD_LDAP_BASE_DN
google_pg_auth.ldap_bind_dn = AD_LDAP_BIND_DN
google_pg_auth.auth_cache_ttl_sec = 3600

      Effettua le seguenti sostituzioni:

      • AD_LDAP_SERVER_HOST: l'URI del server LDAP di Active Directory, ad esempio ldap://ad-controller.example.com.
      • AD_LDAP_BASE_DN: il Base Distinguished Name (DN) per eseguire ricerche LDAP, ad esempio DC=example,DC=com.
      • AD_LDAP_BIND_DN: il nome distinto (DN) dell'account utente Active Directory che AlloyDB Omni utilizza per connettersi ed eseguire ricerche LDAP, ad esempio setupadmin@ad-example.com.
      • auth_cache_ttl_sec è il tempo trascorso prima che i dati vengano memorizzati nella cache da AlloyDB Omni per utente prima che AlloyDB Omni tenti di contattare nuovamente il server LDAP. Il valore di auth_cache_ttl_sec può variare da un minimo di 60 secondi a un massimo di 86.400 secondi (24 ore).

    2. Aggiungi google_pg_auth al parametro shared_preload_libraries in postgresql.conf.

    3. Aggiungi la seguente riga al file postgresql.conf:

      shared_preload_libraries='google_pg_auth,google_columnar_engine,google_job_scheduler,google_storage'

    4. Riavvia il database.

      docker restart CONTAINER_NAME

  3. Configura il certificato LDAPS.

    Per garantire una connessione sicura al server Active Directory tramite LDAPS, devi disporre di un certificato CA.

    Posiziona il file del certificato LDAPS nella seguente posizione predefinita nell'immagine AlloyDB Omni: /etc/ldap/ldap.crt.

Gestire le mappature dei gruppi

Puoi creare e gestire mappature tra i gruppi Active Directory e i ruoli PostgreSQL utilizzando le funzioni SQL.

Accedi al cluster e carica l'estensione

docker exec -it CONTAINER_NAME psql -h localhost -U postgres
postgres=# CREATE EXTENSION google_pg_auth;
CREATE EXTENSION

Creare una mappatura dei gruppi

Per mappare un gruppo Active Directory a un ruolo di gruppo PostgreSQL che hai già creato, utilizza la funzione map_ad_group():

SELECT google_pg_auth.map_ad_group(ad_group_name TEXT, ad_group_sid TEXT, pg_role_name TEXT);

Ad esempio, per mappare il gruppo Active Directory ad-developers al ruolo PostgreSQL pg-developers, utilizza il seguente comando:

SELECT google_pg_auth.map_ad_group('ad-developers', 'S-1-5-21-.....', 'postgres_read_only');

Per recuperare il SID di un gruppo specifico in Active Directory, utilizza il seguente comando sul server Active Directory:

C:\Users\Admin> Get-ADGroup -Identity ad-developers | select SID

             SID
-----------------------------------------------
S-1-5-21-3168537779-1985441202-1799118680-1612

Rimuovere una mappatura dei gruppi

Per rimuovere una mappatura esistente, utilizza la funzione unmap_ad_group(). Questa funzione interrompe la sincronizzazione per il gruppo, ma non rimuove gli utenti dal gruppo PostgreSQL se sono già membri.

SELECT google_pg_auth.unmap_ad_group(ad_group_sid TEXT, pg_role_name TEXT);

Vedi il seguente esempio:

SELECT google_pg_auth.unmap_ad_group('quinn@google.com', 'postgres_read_only');

Connettiti al database AlloyDB Omni

Accedi al database AlloyDB Omni utilizzando l'utente Active Directory. Devi abilitare kinit nel client a cui ti stai connettendo.

Nell'esempio seguente, il pod postgres-client ha installato kinit e psql ed è configurato per connettersi al cluster AlloyDB Omni utilizzando il client psql.

root@postgres-client:/# kinit AD_USER_NAME
Password for user1REALM:

root@postgres-client:/# psql -h ALLOYDB_SERVER_HOST_NAME -U AD_USER_NAME@REALM -d postgres
psql (16.6 (Ubuntu 16.6-0ubuntu0.24.04.1), server 16.3)
GSSAPI-encrypted connection
Type "help" for help.

user1=#

Il tuo accesso nel database AlloyDB Omni viene determinato automaticamente in base a quanto segue:

  • La tua attuale appartenenza ai gruppi Active Directory.
  • I mapping definiti dall'amministratore tra questi gruppi Active Directory e i ruoli PostgreSQL.
  • Le autorizzazioni concesse dall'amministratore a questi ruoli PostgreSQL.

Se è la prima volta che ti connetti, il ruolo utente PostgreSQL (your_ad_user@YOURDOMAIN.COM) viene creato automaticamente.

Ogni volta che accedi, il sistema controlla le tue attuali appartenenze ai gruppi di Active Directory e aggiorna le appartenenze ai ruoli PostgreSQL corrispondenti. Non devi intraprendere alcuna azione specifica per eseguire questa sincronizzazione.

Esempio di connessione al database

Ad esempio, supponiamo che l'utente Quinn faccia parte di un gruppo Active Directory denominato ad_developers. L'amministratore ha mappato ad_developers a un ruolo Postgres denominato pg_read_only. Questo ruolo ha accesso in lettura a una tabella denominata sales. Quando l'utente accede, può accedere alla tabella.

root@postgres-client:/# kinit quinn@REALM
Password for quinn@YOUR.REALM:

root@postgres-client:/# psql -h ALLOYDB_SERVER_HOST_NAME -U quinn@REALM -d postgres
psql (16.6 (Ubuntu 16.6-0ubuntu0.24.04.1), server 16.3)
GSSAPI-encrypted connection
Type "help" for help.

postgres=# select * from sales;
// Query will be run successfully

Nell'esempio seguente, Quinn viene rimosso dal gruppo ad_developers in Active Directory:

root@postgres-client:/# kinit quinn@REALM
Password for quinn@YOUR.REALM:

root@postgres-client:/# psql -h ALLOYDB_SERVER_HOST_NAME -U quinn@REALM -d postgres
psql (16.6 (Ubuntu 16.6-0ubuntu0.24.04.1), server 16.3)
GSSAPI-encrypted connection
Type "help" for help.

postgres=# select * from sales;
// Query will fail

Limitazioni

  • Gestione manuale di gruppi e autorizzazioni: questa funzionalità automatizza solo l'appartenenza degli utenti a gruppi PostgreSQL esistenti. La creazione di questi gruppi e la concessione delle relative autorizzazioni rimane un'attività amministrativa manuale.
  • Latenza di sincronizzazione: l'iscrizione viene sincronizzata solo quando un utente accede. Eventuali modifiche apportate all'appartenenza a un gruppo di un utente in Active Directory vengono riflesse in AlloyDB Omni solo alla successiva sessione di accesso dell'utente.
  • Rendimento: la ricerca LDAP aggiunge una piccola quantità di latenza al processo di accesso iniziale dell'utente. La memorizzazione nella cache contribuisce a ridurre questa latenza per gli accessi successivi entro la durata configurata (auth_cache_ttl_sec).
  • Gestione degli errori: se il server LDAP non è raggiungibile o se si verificano altri errori durante il processo di sincronizzazione, AlloyDB Omni registra l'errore. Tuttavia, l'accesso dell'utente andrà comunque a buon fine perché l'autenticazione GSSAPI è riuscita. Solo la sincronizzazione dell'appartenenza al gruppo per quella sessione non andrà a buon fine.

Passaggi successivi