Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di Autenticazione Kerberos con Aurora PostgreSQL
Puoi utilizzare Kerberos per autenticare gli utenti quando si connettonoal cluster di database che esegue PostgreSQL. A tale scopo, configura l' del cluster DB da utilizzare AWS Directory Service for Microsoft Active Directory per l'autenticazione Kerberos. AWS Directory Service for Microsoft Active Directory viene anche chiamato. AWS Managed Microsoft ADÈ una funzionalità disponibile con Directory Service. Per ulteriori informazioni, vedi [Cos'è Directory Service?](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/what_is.html) nella *Guida all'AWS Directory Service amministrazione*.
Per iniziare, crea una AWS Managed Microsoft AD directory per memorizzare le credenziali dell'utente. Per il cluster di database PostgreSQL, specifica quindi il dominio di Active Directory e altre informazioni. Quando gli utenti eseguono l'autenticazione con il cluster database PostgreSQL, le richieste di autenticazione vengono inoltrate alla directory AWS Managed Microsoft AD .
Mantenere tutte le credenziali nella stessa directory consente di ridurre il tempo e l'impegno. È disponibile una posizione centralizzata per archiviare e gestire le credenziali per più cluster di database. L'uso di una directory può inoltre migliorare il profilo di sicurezza complessivo.
Puoi inoltre accedere alle credenziali da Microsoft Active Directory on-premise. A tale scopo, crea una relazione di dominio trusting in modo che la directory AWS Managed Microsoft AD consideri attendibile Microsoft Active Directory on-premise. In questo modo, gli utenti possono accedere ai cluster PostgreSQL con la stessa esperienza SSO (Single Sign-On) Windows dei carichi di lavoro nella rete locale.
Un database può utilizzare Kerberos AWS Identity and Access Management (IAM) o entrambe le procedure di autenticazione Kerberos e IAM. Tuttavia, poiché l'autenticazione Kerberos e IAM forniscono metodi di autenticazione diversi, un utente del database specifico può accedere a un database utilizzando solo uno o l'altro metodo di autenticazione, ma non entrambi. Per ulteriori informazioni sull’autenticazione IAM, consulta [Autenticazione del database IAM ](UsingWithRDS.IAMDBAuth.md).
**Nota**
RDS per PostgreSQL non supporta l’autenticazione Kerberos per gruppi di Active Directory.
**Topics**
+ [Disponibilità di regioni e versioni](#postgresql-kerberos.RegionVersionAvailability)
+ [Panoramica di Autenticazione Kerberos per cluster di database di PostgreSQL](#postgresql-kerberos-overview)
+ [Configurazione dell'autenticazione Kerberos per cluster di database di PostgreSQL](postgresql-kerberos-setting-up.md)
+ [Gestione di un cluster Aurora PostgreSQL DB (RDS per PostgreSQL) per un'istanza DB PostgreSQL in un Directory](postgresql-kerberos-managing.md)
+ [Connessione a PostgreSQL con Autenticazione Kerberos](postgresql-kerberos-connecting.md)
+ [Utilizzo dei gruppi di sicurezza AD per il controllo degli accessi Aurora PostgreSQL](AD.Security.Groups.md)
## Disponibilità di regioni e versioni
Il supporto varia a seconda delle versioni specifiche di ciascun motore di database e a seconda delle Regioni AWS. Per ulteriori informazioni sulla disponibilità di versioni e regioni di Aurora PostgreSQL con autenticazione Kerberos, consultare [Autenticazione Kerberos con Aurora PostgreSQL](Concepts.Aurora_Fea_Regions_DB-eng.Feature.KerberosAuthentication.md#Concepts.Aurora_Fea_Regions_DB-eng.Feature.KerberosAuthentication.apg).
## Panoramica di Autenticazione Kerberos per cluster di database di PostgreSQL
Per configurare l'autenticazione Kerberos per un cluster di database di PostgreSQL, segui queste fasi, descritte dettagliatamente più avanti:
1. Utilizzare AWS Managed Microsoft AD per creare una AWS Managed Microsoft AD directory. È possibile utilizzare l' Console di gestione AWS AWS CLI, la o l' Directory Service API per creare la directory. Assicurati di aprire le porte in uscita rilevanti nel gruppo di sicurezza della directory in modo che la directory possa comunicare con l'del cluster.
1. Crea un ruolo che fornisca ad Amazon Aurora l'accesso ad Amazon per effettuare chiamate alla tua directory. AWS Managed Microsoft AD A tale scopo, crea un ruolo AWS Identity and Access Management (IAM) che utilizzi la policy IAM gestita. `AmazonRDSDirectoryServiceAccess`
Affinché il ruolo IAM consenta l'accesso, l'endpoint AWS Security Token Service (AWS STS) deve essere attivato nella AWS regione corretta per il tuo AWS account. AWS STS Gli endpoint sono tutti Regioni AWS attivi per impostazione predefinita e puoi utilizzarli senza ulteriori azioni. *Per ulteriori informazioni, consulta [Attivazione e disattivazione AWS STS in una AWS regione nella Guida](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_enable-regions.html#sts-regions-activate-deactivate) per l'utente IAM.*
1. Crea e configura gli utenti nella AWS Managed Microsoft AD directory utilizzando gli strumenti di Microsoft Active Directory. Per ulteriori informazioni sulla creazione di utenti in Active Directory, consulta [Gestire utenti e gruppi in AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups.html) nella *Guida all'Directory Service amministrazione*.
1. Se prevedi di localizzare la directory e l'istanza DB in diversi AWS account o cloud privati virtuali (VPCs), configura il peering VPC. Per ulteriori informazioni, consulta [Che cos'è il peering di VPC?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html) nella *Amazon VPC Peering Guide*.
1. Creare o modificare un cluster di database di PostgreSQL dalla console, da CLI o dall'API di RDS utilizzando uno dei seguenti metodi:
+ [Creazione e connessione di un cluster di database Aurora PostgreSQL](CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.md)
+ [Modifica di un cluster database Amazon Aurora](Aurora.Modifying.md)
+ [Ripristino da uno snapshot cluster database](aurora-restore-snapshot.md)
+ [Ripristino di un cluster di database a un determinato momento](aurora-pitr.md)
Puoi localizzare l' del cluster nello stesso Amazon Virtual Private Cloud (VPC) della directory o in un account AWS o VPC diverso. Quando crei o modifichi l' cluster database PostgreSQL, completa le seguenti operazioni:
+ Specifica l'identificativo del dominio (identificativo `d-*`) generato al momento della creazione della directory.
+ Specifica anche il nome del ruolo IAM creato.
+ Assicurati che il gruppo di sicurezza dell'istanza database possa ricevere traffico in entrata dal gruppo di sicurezza della directory.
1. Utilizzare le credenziali dell'utente master RDS per connettersi al cluster di database di PostgreSQL. Creare l'utente in PostgreSQL per l'identificazione esterna. Gli utenti identificati esternamente possono accedere al cluster database di PostgreSQL con l'autenticazione Kerberos.
# Configurazione dell'autenticazione Kerberos per cluster di database di PostgreSQL
Per configurare l'autenticazione Kerberos, completa la procedura seguente.
**Topics**
+ [Passaggio 1: creare una directory utilizzando AWS Managed Microsoft AD](#postgresql-kerberos-setting-up.create-directory)
+ [Passaggio 2: (Facoltativo) Creare una relazione di fiducia tra Active Directory locale e Directory Service](#postgresql-kerberos-setting-up.create-trust)
+ [Fase 3: creare un ruolo IAM per Amazon Aurora Amazon per accedere a Directory Service](#postgresql-kerberos-setting-up.CreateIAMRole)
+ [Fase 4: creazione e configurazione di utenti](#postgresql-kerberos-setting-up.create-users)
+ [Fase 5: abilitazione del traffico tra VPC tra la directory e l'istanza database](#postgresql-kerberos-setting-up.vpc-peering)
+ [Fase 6: creazione o modifica di un cluster database PostgreSQL](#postgresql-kerberos-setting-up.create-modify)
+ [Fase 7: creazione di utenti PostgreSQL per i principali Kerberos](#postgresql-kerberos-setting-up.create-logins)
+ [Fase 8: configurazione di un client PostgreSQL](#postgresql-kerberos-setting-up.configure-client)
## Passaggio 1: creare una directory utilizzando AWS Managed Microsoft AD
Directory Service crea una Active Directory completamente gestita nel AWS cloud. Quando crei una AWS Managed Microsoft AD directory, Directory Service crea due controller di dominio e server DNS per te. I server di directory vengono creati in sottoreti diverse in un VPC. Questa ridondanza assicura che la directory rimanga accessibile anche se si verifica un errore.
Quando si crea una AWS Managed Microsoft AD AWS directory, Directory Service esegue le seguenti attività per conto dell'utente:
+ Configura una Active Directory all'interno del VPC.
+ Crea un account amministratore della directory con il nome utente `Admin` e la password specificata. Puoi utilizzare questo account per gestire le directory.
**Importante**
Assicurati di salvare questa password. Directory Service non memorizza questa password e non può essere recuperata o reimpostata.
+ Crea un gruppo di sicurezza per i controller della directory. Il gruppo di sicurezza deve consentire la comunicazione con il cluster database PostgreSQL.
All'avvio AWS Directory Service for Microsoft Active Directory, AWS crea un'unità organizzativa (OU) che contiene tutti gli oggetti della directory. Questa unità organizzativa, che ha lo stesso nome NetBIOS che hai immesso al momento della creazione della directory, si trova nella radice del dominio. La radice del dominio è di proprietà e gestita da AWS.
L'`Admin`account creato con la AWS Managed Microsoft AD directory dispone delle autorizzazioni per le attività amministrative più comuni dell'unità organizzativa:
+ Creazione, aggiornamento o eliminazione di utenti
+ Aggiungi risorse al dominio, come file server o server di stampa, e assegna le autorizzazioni per tali risorse a utenti dell'unità organizzativa
+ Crea contenitori aggiuntivi OUs
+ Delega dell'autorità
+ Ripristino degli oggetti eliminati dal cestino di Active Directory
+ Esegui i moduli Active Directory e Domain Name Service (DNS) per Windows PowerShell sul servizio Web Active Directory
L'account `Admin` dispone anche dei diritti per eseguire queste attività in tutto il dominio:
+ gestione delle configurazioni DNS (aggiunta, eliminazione o aggiornamento di record, zone e server d'inoltro);
+ visualizzazione di log di eventi DNS;
+ visualizzazione di log di eventi di sicurezza.
**Per creare una directory con AWS Managed Microsoft AD**
1. Nel riquadro di navigazione della [console Directory Service](https://console.aws.amazon.com/directoryservicev2/), scegliere **Directory**, quindi selezionare **Configurazione della directory**.
1. Scegli **AWS Managed Microsoft AD**. AWS Managed Microsoft AD è l'unica opzione attualmente supportata per l'uso con Amazon Aurora RDS.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Enter directory information (Inserisci le informazioni sulla directory)** inserisci le seguenti informazioni:
**Edizione**
Scegliere l'edizione più adatta alle proprie esigenze.
**Nome DNS directory**
Il nome completo della directory, ad esempio **corp.example.com**.
**Nome NetBIOS della directory**
Nome breve opzionale della directory, ad esempio `CORP`.
**Descrizione della directory**
Descrizione opzionale della directory.
**Password amministratore**
La password dell'amministratore della directory. Con il processo di creazione della directory viene generato un account amministratore con nome utente `Admin` e questa password.
La password dell'amministratore della directory non può includere il termine "admin". La password distingue tra maiuscole e minuscole e la lunghezza deve essere compresa tra 8 e 64 caratteri. Deve anche contenere un carattere di almeno tre delle seguenti quattro categorie:
+ Lettere minuscole (a–z)
+ Lettere maiuscole (A–Z)
+ Numeri (0–9)
+ Caratteri non alfanumerici (\$1\$1@\$1\$1%^&\$1\$1-\$1=`\$1\$1()\$1\$1[]:;"'<>,.?/)
**Confirm password (Conferma password)**
Digitare di nuovo la password dell'amministratore.
Assicurati di salvare questa password. Directory Service non memorizza questa password e non può essere recuperata o reimpostata.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Choose VPC and subnets (Scegli VPC e sottoreti)** fornire le seguenti informazioni:
**VPC**
Scegliere il VPC per la directory. È possibile creare il cluster di database di PostgreSQL in questo VPC o in uno diverso.
**Sottoreti**
Seleziona le sottoreti per i server di directory. Le due sottoreti devono trovarsi in diverse zone di disponibilità.
1. Seleziona **Next** (Successivo).
1. Verificare le informazioni della directory Se sono necessarie modifiche, seleziona **Previous (Precedente)** e apporta le modifiche. Quando le informazioni sono corrette, scegli **Create Directory (Crea directory)**.
![\[Pagina dei dettagli della directory\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/WinAuth2.png)
Per creare la directory sono necessari alcuni minuti. Una volta creata correttamente la directory, il valore **Status (Stato)** viene modificato in **Active (Attivo)**.
Per consultare le informazioni sulla directory, selezionare l’ID della directory nell'elenco di directory. Prendere nota del valore **Directory ID (ID directory)**. Questo valore è necessario per creare o modificare l'istanza database PostgreSQL.
![\[Immagine della pagina dei dettagli\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/WinAuth3.png)
## Passaggio 2: (Facoltativo) Creare una relazione di fiducia tra Active Directory locale e Directory Service
Se non prevedi di utilizzare Microsoft Active Directory locale, passa a [Fase 3: creare un ruolo IAM per Amazon Aurora Amazon per accedere a Directory Service](#postgresql-kerberos-setting-up.CreateIAMRole).
Per ottenere l'autenticazione Kerberos utilizzando l'Active Directory locale, è necessario creare una relazione di dominio affidabile utilizzando un trust di foresta tra Microsoft Active Directory locale e la AWS Managed Microsoft AD directory (creata in). [Passaggio 1: creare una directory utilizzando AWS Managed Microsoft AD](#postgresql-kerberos-setting-up.create-directory) L'attendibilità può essere unidirezionale, in cui la AWS Managed Microsoft AD directory considera attendibile Microsoft Active Directory locale. Il trust può anche essere bidirezionale, in cui entrambe le Active Directory si considerano reciprocamente attendibili. *Per ulteriori informazioni sulla configurazione dei trust utilizzando Directory Service, vedere [Quando creare una relazione di trust](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_setup_trust.html) nella Administration Guide.AWS Directory Service *
**Nota**
Se utilizzi una Microsoft Active Directory locale:
I client Windows devono connettersi utilizzando il nome di dominio di nell'endpoint anziché rds.amazonaws.com Directory Service . Per ulteriori informazioni, consulta [Connessione a PostgreSQL con Autenticazione Kerberos](postgresql-kerberos-connecting.md).
I client Windows non possono connettersi con endpoint personalizzati Aurora. Per ulteriori informazioni, consulta [Connessioni degli endpoint Amazon Aurora](Aurora.Overview.Endpoints.md).
Per i [database globali](aurora-global-database.md):
I client Windows possono connettersi utilizzando endpoint di istanza o endpoint di cluster solo nel database primario del database globale. Regione AWS
I client Windows non possono connettersi utilizzando gli endpoint del cluster in modalità secondaria. Regioni AWS
Assicurati che il nome di dominio di Microsoft Active Directory locale includa un routing del suffisso DNS che corrisponde alla nuova relazione di trust creata. Il risultato è mostrato nella screenshot seguente.
![\[Il routing DNS corrisponde al trust creato\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/kerberos-auth-trust.png)
## Fase 3: creare un ruolo IAM per Amazon Aurora Amazon per accedere a Directory Service
Affinché Amazon Aurora Amazon possa Directory Service chiamarti, il tuo AWS account deve avere un ruolo IAM che utilizzi la policy IAM gestita. `AmazonRDSDirectoryServiceAccess` Questo ruolo permette ad Amazon Aurora di effettuare chiamate ad Directory Service. (Tieni presente che questo ruolo IAM a cui accedere Directory Service è diverso dal ruolo IAM per [Autenticazione del database IAM ](UsingWithRDS.IAMDBAuth.md) cui viene utilizzato.)
Quando crei un'istanza DB utilizzando l'account utente della console Console di gestione AWS e l'account utente della console dispone dell'`iam:CreateRole`autorizzazione, la console crea automaticamente il ruolo IAM necessario. In questo caso, il nome del ruolo è `rds-directoryservice-kerberos-access-role`. In caso contrario, è necessario creare manualmente il ruolo IAM. Quando crei questo ruolo IAM`Directory Service`, scegli e allega la policy AWS gestita `AmazonRDSDirectoryServiceAccess` ad esso.
Per ulteriori informazioni sulla creazione di ruoli IAM per un servizio, consulta [Creating a role to delegate permissions to an AWS service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella *IAM User* Guide.
**Nota**
Il ruolo IAM utilizzato per l'autenticazione Windows per RDS per Microsoft SQL Server non può essere utilizzato per Amazon Aurora.
Facoltativamente, puoi creare policy con le autorizzazioni richieste anziché utilizzare la policy `AmazonRDSDirectoryServiceAccess` gestita. In questo caso, il ruolo IAM deve avere la seguente policy di attendibilità IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"directoryservice.rds.amazonaws.com",
"rds.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Il ruolo deve anche disporre della seguente policy del ruolo IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"ds:DescribeDirectories",
"ds:AuthorizeApplication",
"ds:UnauthorizeApplication",
"ds:GetAuthorizedApplicationDetails"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Per l'attivazione Regioni AWS, utilizza i principali di servizio specifici della regione nelle policy di fiducia dei ruoli IAM. Quando si crea crei una policy di attendibilità per i servizi in queste Regioni, specificare il codice regionale nel principale di servizio.
L’esempio seguente mostra una policy di attendibilità che include i principali del servizio specifici della Regione:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"directoryservice.rds.REGION-CODE.amazonaws.com",
"rds.REGION-CODE.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Sostituire REGION-CODE con il codice della Regione specifica. Ad esempio, utilizzare i seguenti principali del servizio per la Regione Asia Pacifico (Melbourne):
```
"Service": [
"directoryservice.rds.ap-southeast-4.amazonaws.com",
"rds.ap-southeast-4.amazonaws.com"
]
```
## Fase 4: creazione e configurazione di utenti
Puoi creare gli utenti con lo strumento Utenti Active Directory e computer. Questo è uno degli strumenti di Active Directory Domain Services e Active Directory Lightweight Directory Services. Per ulteriori informazioni, consulta [Add Users and Computers to the Active Directory domain](https://learn.microsoft.com/en-us/troubleshoot/windows-server/identity/create-an-active-directory-server#add-users-and-computers-to-the-active-directory-domain) (Aggiungere utenti e computer al dominio di Active Directory) nella documentazione di Microsoft. In questo caso, gli utenti sono individui o altre entità, ad esempio i computer, che fanno parte del dominio e le cui identità vengono conservate nella directory.
Per creare utenti in una Directory Service directory, devi essere connesso a un'istanza Amazon EC2 basata su Windows che fa parte della directory. Directory Service Allo stesso tempo, devi essere connesso come un utente che dispone di privilegi per creare utenti. Per ulteriori informazioni, consulta [Creazione di un utente](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_manage_users_groups_create_user.html) nella *Guida di amministrazione di AWS Directory Service *.
## Fase 5: abilitazione del traffico tra VPC tra la directory e l'istanza database
Se prevedi di individuare la directory e il cluster di database nello stesso VPC, ignora questa fase e passa a [Fase 6: creazione o modifica di un cluster database PostgreSQL](#postgresql-kerberos-setting-up.create-modify).
[Se prevedi di localizzare la directory e l'istanza DB in modo diverso VPCs, configura il traffico cross-VPC utilizzando il peering VPC o il Transit Gateway.AWS](https://docs.aws.amazon.com/vpc/latest/tgw/what-is-transit-gateway.html)
La procedura seguente abilita il traffico tra un VPCs utilizzo e l'altro del peering VPC. Segui le istruzioni in [Che cos'è il peering di VPC?](https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html) nella *Amazon Virtual Private Cloud Peering Guide*.
**Per abilitare il traffico tra VPC utilizzando il peering di VPC**
1. Configurare le regole di routing VPC appropriate per garantire che il traffico di rete possa scorrere in entrambe le direzioni.
1. Assicurati che il gruppo di sicurezza dell'istanza database possa ricevere traffico in entrata dal gruppo di sicurezza della directory.
1. Assicurati che non sia presente una regola della lista di controllo accessi (ACL) di rete per bloccare il traffico.
Se la directory è di proprietà di un altro AWS account, è necessario condividerla.
**Per condividere la cartella tra AWS account**
1. *Inizia a condividere la directory con l' AWS account in cui verrà creata l'istanza DB seguendo le istruzioni riportate nel [Tutorial: Sharing your AWS Managed Microsoft AD directory for seamless EC2 Domain-join](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_tutorial_directory_sharing.html) nella Administration Guide.Directory Service *
1. Accedi alla Directory Service console utilizzando l'account per l'istanza DB e assicurati che il dominio abbia lo stato prima di procedere. `SHARED`
1. Dopo aver effettuato l'accesso alla Directory Service console utilizzando l'account per l'istanza DB, annota il valore **Directory ID**. Utilizzare questo ID directory per aggiungere l'istanza database al dominio.
## Fase 6: creazione o modifica di un cluster database PostgreSQL
Crea o modifica un cluster di database di PostgreSQL da usare con la directory. Puoi utilizzare la console, CLI o l'API di RDS per associare un cluster di database a una directory. Questa operazione può essere eseguita in uno dei seguenti modi:
+ [Crea un nuovo cluster DB PostgreSQL utilizzando la console, il comando [create-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-cluster.html)CLI o l'operazione Create RDS API. DBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBCluster.html) Per istruzioni, consulta [Creazione e connessione di un cluster di database Aurora PostgreSQL](CHAP_GettingStartedAurora.CreatingConnecting.AuroraPostgreSQL.md).
+ [Modifica un cluster PostgreSQL DB esistente utilizzando la console, il comando [modify-db-cluster](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-cluster.html)CLI o l'operazione Modify RDS API. DBCluster](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBCluster.html) Per istruzioni, consulta [Modifica di un cluster database Amazon Aurora](Aurora.Modifying.md).
+ [Ripristina un cluster DB PostgreSQL da un'istantanea DB utilizzando la console, il comando CLI [restore-db-cluster-from-db-snapshot o l'operazione dell'API](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-from-snapshot.html) Restore From RDS. DBCluster DBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterFromSnapshot.html) Per istruzioni, consulta [Ripristino da uno snapshot cluster database](aurora-restore-snapshot.md).
+ [Ripristina un cluster DB PostgreSQL utilizzando la console, il comando [restore-db-instance-to- point-in-time CLI o l'operazione](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-cluster-to-point-in-time.html) Restore RDS API. point-in-time DBCluster ToPointInTime](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBClusterToPointInTime.html) Per istruzioni, consulta [Ripristino di un cluster di database a un determinato momento](aurora-pitr.md).
L'autenticazione Kerberos è supportata solo per cluster di PostgreSQL DB in un VPC. Il cluster di database può trovarsi nello stesso VPC della directory o in un VPC diverso. Il cluster database deve utilizzare un gruppo di sicurezza che accetta traffico in ingresso e in uscita all'interno del VPC della directory, in modo che il cluster database possa comunicare con la directory.
**Nota**
L’abilitazione dell’autenticazione Kerberos non è attualmente supportata sul cluster di database Aurora PostgreSQL durante la migrazione da RDS per PostgreSQL. È possibile abilitare l’autenticazione Kerberos solo su un cluster di database Aurora PostgreSQL autonomo.
### Console
Quando utilizzi la console per creare, modificare o ripristinare un cluster di database, scegli **Autenticazione Kerberos** nella sezione **Autenticazione database**. Quindi scegli **Sfoglia directory**. Seleziona la directory o seleziona **Crea una nuova directory** per utilizzare il servizio directory.
![\[Scelta di Kerberos per l'autenticazione e l'identificazione della directory da utilizzare.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/rpg-authentication-use-kerberos.png)
### AWS CLI
Quando si utilizza il AWS CLI, sono necessari i seguenti parametri affinché l' del cluster DB possa utilizzare la directory creata:
+ Per il parametro `--domain`, utilizza l'identificatore di dominio (identificatore "d-\$1") generato durante la creazione della directory.
+ Per il parametro `--domain-iam-role-name`, utilizza il ruolo creato che utilizza la policy IAM gestita `AmazonRDSDirectoryServiceAccess`.
Ad esempio, il comando CLI seguente modifica un cluster di database per utilizzare una directory.
```
aws rds modify-db-cluster --db-cluster-identifier mydbinstance --domain d-Directory-ID --domain-iam-role-name role-name
```
**Importante**
Se modifichi un cluster database per abilitare l'autenticazione Kerberos, riavvia il cluster database dopo aver apportato la modifica.
## Fase 7: creazione di utenti PostgreSQL per i principali Kerberos
A questo punto, il cluster di database Aurora PostgreSQL viene aggiunto al dominio AWS Managed Microsoft AD . Gli utenti che hai creato nella directory in [Fase 4: creazione e configurazione di utenti](#postgresql-kerberos-setting-up.create-users) devono essere impostati come utenti del database PostgreSQL e devono essere concessi loro i privilegi per accedere al database. Puoi farlo accedendo come utente del database con privilegi `rds_superuser`. Ad esempio, se hai accettato i valori predefiniti quando hai creato il cluster database Aurora PostgreSQL, utilizzi `postgres`, come illustrato nei passaggi seguenti.
**Per creare utenti del database PostgreSQL per i principali Kerberos**
1. Usa `psql` per la connessione all'endpoint dell'istanza database del cluster database Aurora PostgreSQL utilizzando `psql`. L'esempio seguente utilizza l'account `postgres` predefinito per il ruolo `rds_superuser`.
```
psql --host=cluster-instance-1.111122223333.aws-region.rds.amazonaws.com --port=5432 --username=postgres --password
```
1. Crea un nome utente del database per ogni principale Kerberos (nome utente di Active Directory) a cui desideri fornire l'accesso al database. Utilizza il nome utente canonico (identità) come definito nell'istanza Active Directory, ovvero un `alias` minuscolo (nome utente in Active Directory) e il nome maiuscolo del dominio Active Directory per quel nome utente. Il nome utente di Active Directory è un utente autenticato esternamente, quindi usa le virgolette intorno al nome come mostrato di seguito.
```
postgres=> CREATE USER "username@CORP.EXAMPLE.COM" WITH LOGIN;
CREATE ROLE
```
1. Autorizza il ruolo `rds_ad` per l'utente del database.
```
postgres=> GRANT rds_ad TO "username@CORP.EXAMPLE.COM";
GRANT ROLE
```
Dopo aver completato la creazione di tutti gli utenti PostgreSQL per le identità utente Active Directory, gli utenti possono accedere al cluster database Aurora PostgreSQL utilizzando le proprie credenziali Kerberos.
È necessario che gli utenti del database che eseguono l’autenticazione tramite Kerberos la effettuino attraverso computer client membri del dominio Active Directory.
Gli utenti del database a cui è stato concesso il ruolo `rds_ad` non possono avere anche il ruolo `rds_iam`. Questo vale anche per le appartenenze nidificate. Per ulteriori informazioni, consulta [Autenticazione del database IAM ](UsingWithRDS.IAMDBAuth.md).
### Configurazione del cluster database Aurora PostgreSQL per nomi utente senza distinzione tra maiuscole e minuscole
Le versioni di Aurora PostgreSQL 14.5, 13.8, 12.12 e 11.17 supportano il parametro PostgreSQL `krb_caseins_users`. Questo parametro supporta i nomi utente di Active Directory senza distinzione tra maiuscole e minuscole. Per impostazione predefinita, questo parametro è impostato su false, quindi i nomi utente vengono interpretati applicando la distinzione tra maiuscole e minuscole da Aurora PostgreSQL. Questo è il comportamento predefinito in tutte le precedenti versioni di Aurora PostgreSQL. Tuttavia, puoi impostare questo parametro su `true` nel gruppo di parametri del·cluster database personalizzato e consentire al cluster database Aurora PostgreSQL di interpretare i nomi utente, senza distinzione tra maiuscole e minuscole. Questa operazione può essere utile per gli utenti del database, che a volte potrebbero digitare in modo errato le maiuscole e le minuscole del proprio nome utente durante l'autenticazione tramite Active Directory.
Per modificare il parametro `krb_caseins_users`, il cluster database Aurora PostgreSQL deve usare un gruppo di parametri del cluster database personalizzato. Per informazioni sull'utilizzo di un gruppo di parametri del·cluster database personalizzato, consulta [Gruppi di parametri per Amazon Aurora](USER_WorkingWithParamGroups.md).
È possibile utilizzare AWS CLI o the Console di gestione AWS per modificare l'impostazione. Per ulteriori informazioni, consulta [Modifica dei parametri in un gruppo di parametri del cluster DB in Amazon Aurora](USER_WorkingWithParamGroups.ModifyingCluster.md).
## Fase 8: configurazione di un client PostgreSQL
Per configurare un client PostgreSQL, procedi come indicato di seguito:
+ Crea un file krb5.conf (o equivalente) che punti al dominio.
+ Verifica che il traffico possa fluire tra l'host del client e Directory Service. Utilizza un'utilità di rete come Netcat per le operazioni seguenti:
+ Verifica il traffico su DNS per la porta 53.
+ Verifica il traffico verso TCP/UDP la porta 53 e per Kerberos, che include le porte 88 e 464 per. Directory Service
+ Verifica che il traffico scorra senza problemi tra l'host client e l'istanza database sulla porta del database. Ad esempio, utilizza psql per connetterti e accedere al database.
Di seguito è riportato un esempio di contenuto krb5.conf per. AWS Managed Microsoft AD
```
[libdefaults]
default_realm = EXAMPLE.COM
[realms]
EXAMPLE.COM = {
kdc = example.com
admin_server = example.com
}
[domain_realm]
.example.com = EXAMPLE.COM
example.com = EXAMPLE.COM
```
Di seguito è riportato un esempio di contenuto krb5.conf per una Microsoft Active Directory locale.
```
[libdefaults]
default_realm = EXAMPLE.COM
[realms]
EXAMPLE.COM = {
kdc = example.com
admin_server = example.com
}
ONPREM.COM = {
kdc = onprem.com
admin_server = onprem.com
}
[domain_realm]
.example.com = EXAMPLE.COM
example.com = EXAMPLE.COM
.onprem.com = ONPREM.COM
onprem.com = ONPREM.COM
.rds.amazonaws.com = EXAMPLE.COM
.amazonaws.com.rproxy.govskope.ca.cn = EXAMPLE.COM
.amazon.com = EXAMPLE.COM
```
# Gestione di un cluster Aurora PostgreSQL DB (RDS per PostgreSQL) per un'istanza DB PostgreSQL in un Directory
È possibile utilizzare la console, l’interfaccia a riga di comando (CLI) o l’API RDS per gestire il cluster di database e la relativa relazione con Microsoft Active Directory. Ad esempio, puoi associare una Active Directory per abilitare l'autenticazione Kerberos. Puoi anche annullare l'associazione ad Active Directory per disabilitare l'autenticazione Kerberos. Puoi anche spostare un cluster di database affinché venga autenticata esternamente da una Microsoft Active Directory a un'altra.
Ad esempio, utilizzando la CLI, puoi effettuare quanto segue:
+ Per riprovare ad abilitare l'autenticazione Kerberos per un'iscrizione non riuscita, usa il comando CLI. Specifica l'ID della directory dell'appartenenza corrente per l'opzione `--domain`.
+ Per disabilitare l'autenticazione Kerberos su un'istanza DB, utilizzare il comando CLI . Specifica `none` per l'opzione `--domain`.
+ Per spostare un'istanza DB da un dominio all'altro, usa il comando CLI. Specifica l'identificatore del nuovo dominio per l'opzione `--domain`.
## Appartenenza al dominio
Dopo avere creato o modificato il cluster database, le istanze database diventano membri del dominio. È possibile visualizzare lo stato dell'appartenenza al dominio nella console o eseguendo il comando [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html)CLI. Lo stato dell'istanza di database può essere uno dei seguenti:
+ `kerberos-enabled`: l'autenticazione Kerberos è abilitata nell'istanza database.
+ `enabling-kerberos`— AWS sta abilitando l'autenticazione Kerberos su questa istanza DB.
+ `pending-enable-kerberos`: l'abilitazione dell'autenticazione Kerberos è in corso su questa istanza database.
+ `pending-maintenance-enable-kerberos`— AWS tenterà di abilitare l'autenticazione Kerberos sull'istanza DB durante la successiva finestra di manutenzione pianificata.
+ `pending-disable-kerberos`: la disabilitazione dell'autenticazione Kerberos è in corso su questa istanza database.
+ `pending-maintenance-disable-kerberos`— AWS tenterà di disabilitare l'autenticazione Kerberos sull'istanza DB durante la successiva finestra di manutenzione programmata.
+ `enable-kerberos-failed`— Un problema di configurazione ha AWS impedito l'attivazione dell'autenticazione Kerberos sull'istanza DB. Correggi il problema di configurazione prima di inviare nuovamente il comando per modificare l'istanza database.
+ `disabling-kerberos`— AWS sta disabilitando l'autenticazione Kerberos su questa istanza DB.
Una richiesta per abilitare l'autenticazione Kerberos potrebbe non andare a buon fine a causa di un problema di connettività di rete o un ruolo IAM non corretto. In alcuni casi, il tentativo di abilitare l'autenticazione Kerberos potrebbe non riuscire quando crei o modifichi un cluster di database. In questo caso, verifica di utilizzare il ruolo IAM corretto, quindi modifica il cluster di database per l'aggiunta al dominio.
# Connessione a PostgreSQL con Autenticazione Kerberos
Puoi connetterti a PostgreSQL con l'autenticazione Kerberos tramite l'interfaccia pgAdmin o un'interfaccia a riga di comando come psql. Per ulteriori informazioni sulla connessione, consulta [Connessione a un cluster di database Amazon Aurora PostgreSQL](Aurora.Connecting.md#Aurora.Connecting.AuroraPostgreSQL). Per informazioni su come ottenere l’endpoint, il numero di porta e altri dettagli necessari per la connessione, consulta [Visualizzazione degli endpoint per un cluster Aurora](Aurora.Overview.Endpoints.md#Aurora.Endpoints.Viewing).
**Nota**
L’autenticazione e la crittografia GSSAPI in PostgreSQL sono implementate dalla libreria Kerberos `libkrb5.so`. Funzionalità come `postgres_fdw` e `dblink` si basano anche su questa stessa libreria per le connessioni in uscita con autenticazione o crittografia Kerberos.
## pgAdmin
Per utilizzare pgAdmin per connetterti a PostgreSQL con l'autenticazione Kerberos, completa la procedura seguente:
1. Avviare l'applicazione pgAdmin sul computer client.
1. Nella scheda **Dashboard (Pannello di controllo)** selezionare **Add New Server (Aggiungi nuovo server)**.
1. Nella finestra di dialogo **Crea - Server**, immettere un nome nella scheda **Generale** per identificare il server in pgAdmin.
1. Nella scheda **Connection** (Connessione), immetti le informazioni seguenti relative al database Aurora PostgreSQL.
+ In **Host**, immetti l'endpoint per l'istanza di scrittura del cluster database Aurora PostgreSQL. Un endpoint è simile al seguente:
```
AUR-cluster-instance.111122223333.aws-region.rds.amazonaws.com
```
Per connettersi a un Microsoft Active Directory locale da un client Windows, si utilizza il nome di dominio di AWS Managed Active Directory anziché `rds.amazonaws.com` nell'endpoint host. Ad esempio, supponiamo che il nome di dominio per AWS Managed Active Directory sia. `corp.example.com` In **Host**, l'endpoint viene quindi specificato come segue:
```
AUR-cluster-instance.111122223333.aws-region.corp.example.com
```
+ Per **Porta**, immettere la porta assegnata.
+ In **Database di manutenzione** immettere il nome del database iniziale a cui si connetterà il client.
+ In **Nome utente**, immettere il nome utente immesso per l'autenticazione Kerberos in [Fase 7: creazione di utenti PostgreSQL per i principali Kerberos](postgresql-kerberos-setting-up.md#postgresql-kerberos-setting-up.create-logins).
1. Scegli **Save** (Salva).
## Psql
Per utilizzare psql per connetterti a PostgreSQL con l'autenticazione Kerberos, completare la procedura seguente:
1. Al prompt dei comandi, eseguire questo comando.
```
kinit username
```
Sostituire *`username`* con il nome utente. Al prompt, immettere la password per l'utente memorizzata in Microsoft Active Directory.
1. Se il cluster database PostgreSQL utilizza un VPC accessibile pubblicamente, inserire un indirizzo IP per l'endpoint del cluster database nel file `/etc/hosts` nelclient EC2. Ad esempio, i comandi seguenti ottengono l'indirizzo IP e lo inseriscono nel file `/etc/hosts`.
```
% dig +short PostgreSQL-endpoint.AWS-Region.rds.amazonaws.com
;; Truncated, retrying in TCP mode.
ec2-34-210-197-118.AWS-Region.compute.amazonaws.com.
34.210.197.118
% echo " 34.210.197.118 PostgreSQL-endpoint.AWS-Region.rds.amazonaws.com" >> /etc/hosts
```
Se utilizzi una Microsoft Active Directory locale da un client Windows, dovrai connetterti utilizzando un endpoint speciale. Invece di utilizzare il dominio Amazon `rds.amazonaws.com` nell'endpoint host, utilizza il nome di dominio di AWS Managed Active Directory.
Ad esempio, supponiamo che il nome di dominio per la tua Active Directory AWS gestita sia. `corp.example.com` Quindi utilizzare il formato `PostgreSQL-endpoint.AWS-Region.corp.example.com` per l'endpoint e inserirlo nel file `/etc/hosts`.
```
% echo " 34.210.197.118 PostgreSQL-endpoint.AWS-Region.corp.example.com" >> /etc/hosts
```
1. Utilizzare il comando psql seguente per accedere a un cluster di database PostgreSQL integrata con Active Directory. Utilizzare un cluster o un endpoint dell'istanza.
```
psql -U username@CORP.EXAMPLE.COM -p 5432 -h PostgreSQL-endpoint.AWS-Region.rds.amazonaws.com postgres
```
Per accedere al cluster di database PostgreSQL da un client Windows utilizzando una Active Directory locale, utilizzare il comando psql seguente con il nome di dominio del passaggio precedente (`corp.example.com`):
```
psql -U username@CORP.EXAMPLE.COM -p 5432 -h PostgreSQL-endpoint.AWS-Region.corp.example.com postgres
```
# Utilizzo dei gruppi di sicurezza AD per il controllo degli accessi Aurora PostgreSQL
A partire dalle versioni Aurora PostgreSQL 14.10 e 15.5, il controllo degli accessi di Aurora PostgreSQL può essere gestito utilizzando Directory Service per i gruppi di sicurezza Microsoft Active Directory (AD). AWS Le versioni precedenti di Aurora PostgreSQL supportano l’autenticazione basata su Kerberos con AD solo per utenti singoli. Ogni utente AD doveva essere assegnato in modo esplicito al cluster di database per ottenere l’accesso.
Invece di effettuare in modo esplicito il provisioning di ciascun utente AD al cluster di database in base alle esigenze aziendali, è possibile sfruttare i gruppi di sicurezza AD come spiegato di seguito:
+ Gli utenti AD sono membri di vari gruppi di sicurezza AD in Active Directory. Questi non sono dettati dall’amministratore del cluster di database, ma si basano su requisiti aziendali e sono gestiti da un amministratore AD.
+ Gli amministratori dei cluster di database creano ruoli di database nelle istanze database in base ai requisiti aziendali. Questi ruoli di database possono avere autorizzazioni o privilegi diversi.
+ Gli amministratori dei cluster di database configurano una mappatura dai gruppi di sicurezza AD ai ruoli di database per ogni cluster di database.
+ Gli utenti di database possono accedere ai cluster di database utilizzando le proprie credenziali AD. L’accesso si basa sull’appartenenza al gruppo di sicurezza AD. Gli utenti AD ottengono o perdono automaticamente l’accesso in base all’appartenenza ai gruppi AD.
## Prerequisiti
Assicurati di disporre di quanto segue prima di configurare l’estensione per i gruppi di sicurezza AD:
+ È possibile configurare l’autenticazione Kerberos per cluster di database PostgreSQL. Per ulteriori informazioni, consulta [Setting up Kerberos authentication for PostgreSQL DB clusters](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/postgresql-kerberos-setting-up.html).
**Nota**
Per i gruppi di sicurezza AD, salta il passaggio 7: Creare utenti PostgreSQL per i principali Kerberos in questa procedura di configurazione.
**Importante**
Se si abilitano i gruppi di sicurezza AD su un cluster Aurora PostgreSQL in cui è già abilitata l’autenticazione Kerberos, potrebbero verificarsi problemi di autenticazione. Ciò si verifica quando si aggiunge `pg_ad_mapping` al parametro `shared_preload_libraries` e si riavvia il database. Quando si utilizzano gli endpoint del cluster, i tentativi di accesso con un utente AD che non è un utente di database con il ruolo `rds_ad` possono avere esito negativo. Ciò può anche causare potenziali arresti anomali del motore. Per risolvere questo problema, disattivare e riattivare l’autenticazione Kerberos sul cluster. Questa soluzione alternativa è necessaria per le istanze esistenti ma non influisce sulle istanze create dopo aprile 2025.
+ È possibile gestire un cluster di database in un dominio. Per ulteriori informazioni, consulta [Gestione di un cluster di database in un dominio](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/postgresql-kerberos-managing.html).
## Configurazione dell’estensione pg\$1ad\$1mapping
Aurora PostgreSQL fornisce ora un’estensione `pg_ad_mapping` per gestire la mappatura tra gruppi di sicurezza AD e ruoli di database nel cluster Aurora PostgreSQL. Per ulteriori informazioni sulle funzioni fornite da `pg_ad_mapping`, consulta [Utilizzo delle funzioni dall’estensione `pg_ad_mapping`](#AD.Security.Groups.functions).
Per configurare l’estensione `pg_ad_mapping` sul cluster di database Aurora PostgreSQL, aggiungere innanzitutto `pg_ad_mapping` alle librerie condivise nel gruppo di parametri del cluster di database personalizzato per il cluster di database Aurora PostgreSQL. Per informazioni sulla creazione di un gruppo di parametri del cluster di database personalizzato, consulta [Gruppi di parametri per Amazon Aurora](USER_WorkingWithParamGroups.md). Quindi, installa l’estensione `pg_ad_mapping`. Le procedure in questa sezione mostrano come fare. È possibile utilizzare o il. Console di gestione AWS AWS CLI
Per eseguire tutte queste attività, sono richieste autorizzazioni come il ruolo `rds_superuser`.
I passaggi seguenti si basano sull’ipotesi che il cluster di database Aurora PostgreSQL sia associato a un gruppo di parametri del cluster di database personalizzato.
### Console
**Come configurare l’estensione `pg_ad_mapping`**
1. Accedi a Console di gestione AWS e apri la console Amazon RDS all'indirizzo [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Nel riquadro di navigazione, scegli l’istanza di scrittura del cluster di database Aurora PostgreSQL.
1. Apri la scheda **Configurazione** per l’istanza di scrittura del cluster di database Aurora PostgreSQL. Tra i dettagli dell’istanza, individua il collegamento **Gruppo di parametri**.
1. Scegli il collegamento per aprire i parametri personalizzati associati al cluster database Aurora PostgreSQL.
1. Nel campo di ricerca **Parametri**, digita `shared_pre` per trovare il parametro `shared_preload_libraries`.
1. Scegli **Edit parameters** (Modifica parametri) per accedere ai valori delle proprietà.
1. Aggiungi `pg_ad_mapping` all’elenco nel campo **Values** (Valori). Utilizza una virgola per separare gli elementi nell’elenco di valori.
![\[Immagine del parametro shared_preload_libaries con pgAudit aggiunto.\]](http://docs.aws.amazon.com/it_it/AmazonRDS/latest/AuroraUserGuide/images/apg_shared_preload_pgadmapping.png)
1. Riavvia l’istanza di scrittura del cluster di database Aurora PostgreSQL in modo da rendere effettiva la modifica al parametro `shared_preload_libraries`.
1. Quando l’istanza è disponibile, verifica che `pg_ad_mapping` sia stato inizializzato. Utilizza `psql` per connettersi all’istanza di scrittura del cluster di database Aurora PostgreSQL, quindi esegui il comando seguente.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pg_ad_mapping
(1 row)
```
1. Con `pg_ad_mapping` inizializzato, puoi ora creare l’estensione. L’estensione deve essere creata dopo aver inizializzato la libreria per iniziare a utilizzare le funzioni fornite da questa estensione.
```
CREATE EXTENSION pg_ad_mapping;
```
1. Chiudi la sessione `psql`.
```
labdb=> \q
```
### AWS CLI
**Come configurare pg\$1ad\$1mapping**
Per configurare pg\$1ad\$1mapping utilizzando il AWS CLI, richiama l'[modify-db-parameter-group](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-parameter-group.html)operazione per aggiungere questo parametro nel gruppo di parametri personalizzato, come illustrato nella procedura seguente.
1. Utilizzate il AWS CLI comando seguente per aggiungere al parametro. `pg_ad_mapping` `shared_preload_libraries`
```
aws rds modify-db-parameter-group \
--db-parameter-group-name custom-param-group-name \
--parameters "ParameterName=shared_preload_libraries,ParameterValue=pg_ad_mapping,ApplyMethod=pending-reboot" \
--region aws-region
```
1. Usa il AWS CLI comando seguente per riavviare l'istanza writer del cluster Aurora PostgreSQL DB in modo da inizializzare pg\$1ad\$1mapping.
```
aws rds reboot-db-instance \
--db-instance-identifier writer-instance \
--region aws-region
```
1. Quando l’istanza è disponibile, verifica che `pg_ad_mapping` sia stato inizializzato. Utilizza `psql` per connettersi all’istanza di scrittura del cluster di database Aurora PostgreSQL, quindi esegui il comando seguente.
```
SHOW shared_preload_libraries;
shared_preload_libraries
--------------------------
rdsutils,pg_ad_mapping
(1 row)
```
Con pg\$1ad\$1mapping inizializzato, puoi ora creare l’estensione.
```
CREATE EXTENSION pg_ad_mapping;
```
1. Chiudi la sessione `psql` in modo da poter utilizzare AWS CLI.
```
labdb=> \q
```
## Recupero del SID del gruppo Active Directory in PowerShell
Un identificatore di sicurezza (SID) viene utilizzato per identificare in modo univoco un principale di sicurezza o un gruppo di sicurezza. Ogni volta che un gruppo di sicurezza o un account viene creato in Active Directory, gli viene assegnato un SID. Per recuperare il SID del gruppo di sicurezza AD da Active Directory, è possibile utilizzare il Get-ADGroup cmdlet dal computer client Windows che fa parte di quel dominio Active Directory. Il parametro Identity specifica il nome del gruppo Active Directory per ottenere il SID corrispondente.
L'esempio seguente restituisce il SID del gruppo AD. *adgroup1*
```
C:\Users\Admin> Get-ADGroup -Identity adgroup1 | select SID
SID
-----------------------------------------------
S-1-5-21-3168537779-1985441202-1799118680-1612
```
## Mappatura del ruolo di database con il gruppo di sicurezza AD
È necessario eseguire il provisioning in modo esplicito dei gruppi di sicurezza AD nel database come ruolo di database PostgreSQL. Un utente AD, che fa parte di almeno un gruppo di sicurezza AD di cui è stato eseguito il provisioning, avrà accesso al database. Non è consigliabile concedere `rds_ad role` al ruolo di database basato sulla sicurezza del gruppo AD. L'autenticazione Kerberos per il gruppo di sicurezza verrà attivata utilizzando il suffisso del nome di dominio like. *user1@example.com* Questo ruolo di database non può utilizzare l’autenticazione tramite password o IAM per accedere al database.
**Nota**
Gli utenti AD che hanno un ruolo di database corrispondente nel database a cui è stato concesso il ruolo `rds_ad` non possono accedere come parte del gruppo di sicurezza AD. Avranno accesso tramite il ruolo di database come utente individuale.
Ad esempio, accounts-group è un gruppo di sicurezza in AD in cui si desidera eseguire il provisioning di questo gruppo di sicurezza in Aurora PostgreSQL come accounts-role.
| Gruppo di sicurezza AD | Ruolo di database di PostgreSQL |
| --- | --- |
| accounts-group | accounts-role |
Quando si esegue la mappatura del ruolo di database con il gruppo di sicurezza AD, è necessario assicurarsi che il ruolo di database abbia l’attributo LOGIN impostato e che disponga del privilegio CONNECT sul database di accesso richiesto.
```
postgres => alter role accounts-role login;
ALTER ROLE
postgres => grant connect on database accounts-db to accounts-role;
```
L’amministratore può ora procedere alla creazione della mappatura tra il gruppo di sicurezza AD e il ruolo di database di PostgreSQL.
```
admin=>select pgadmap_set_mapping('accounts-group', 'accounts-role', , );
```
Per informazioni sul recupero del SID del gruppo di sicurezza AD, consulta [Recupero del SID del gruppo Active Directory in PowerShell](#AD.Security.Groups.retrieving).
Potrebbero verificarsi casi in cui un utente AD appartiene a più gruppi; in tal caso, l’utente AD erediterà i privilegi del ruolo di database, di cui è stato eseguito il provisioning con il peso più elevato. Se i due ruoli hanno lo stesso peso, l’utente AD erediterà i privilegi del ruolo di database corrispondente alla mappatura aggiunta di recente. Si consiglia di specificare pesi che riflettano i ruoli relativi permissions/privileges ai singoli ruoli del DB. Maggiore è il livello di autorizzazioni o privilegi di un ruolo di database, maggiore sarà il peso da associare alla voce di mappatura. Ciò eviterà l’ambiguità di due mappature aventi lo stesso peso.
La tabella seguente mostra un esempio di mappatura dai gruppi di sicurezza AD ai ruoli di database di Aurora PostgreSQL.
| Gruppo di sicurezza AD | Ruolo di database di PostgreSQL | Weight |
| --- | --- | --- |
| accounts-group | accounts-role | 7 |
| sales-group | sales-role | 10 |
| dev-group | dev-role | 7 |
Nell’esempio seguente, `user1` erediterà i privilegi di sales-role poiché ha il peso maggiore, mentre `user2` erediterà i privilegi di `dev-role` poiché la mappatura per questo ruolo è stata creata dopo `accounts-role`, che ha lo stesso peso di `accounts-role`.
| Username | Appartenenza al gruppo di sicurezza |
| --- | --- |
| user1 | accounts-group sales-group |
| user2 | accounts-group dev-group |
I comandi psql per stabilire, elencare e cancellare le mappature sono mostrati di seguito. Al momento non è possibile modificare una singola voce di mappatura. La voce esistente deve essere eliminata e la mappatura deve essere ricreata.
```
admin=>select pgadmap_set_mapping('accounts-group', 'accounts-role', 'S-1-5-67-890', 7);
admin=>select pgadmap_set_mapping('sales-group', 'sales-role', 'S-1-2-34-560', 10);
admin=>select pgadmap_set_mapping('dev-group', 'dev-role', 'S-1-8-43-612', 7);
admin=>select * from pgadmap_read_mapping();
ad_sid | pg_role | weight | ad_grp
-------------+----------------+--------+---------------
S-1-5-67-890 | accounts-role | 7 | accounts-group
S-1-2-34-560 | sales-role | 10 | sales-group
S-1-8-43-612 | dev-role | 7 | dev-group
(3 rows)
```
## Registrazione di log/audit dell’identità dell’utente AD
Utilizza il comando seguente per determinare il ruolo di database ereditato dall’utente corrente o di sessione:
```
postgres=>select session_user, current_user;
session_user | current_user
-------------+--------------
dev-role | dev-role
(1 row)
```
Per determinare l’identità del principale di sicurezza AD, utilizza il seguente comando:
```
postgres=>select principal from pg_stat_gssapi where pid = pg_backend_pid();
principal
-------------------------
user1@example.com
(1 row)
```
Attualmente, l’identità dell’utente AD non è visibile nei log di audit. È possibile abilitare il parametro `log_connections` per registrare log della creazione della sessione di database. Per ulteriori informazioni, consulta [log\$1connections](https://docs.aws.amazon.com/prescriptive-guidance/latest/tuning-postgresql-parameters/log-connections.html). L’output risultante include l’identità dell’utente AD, come illustrato di seguito. Il PID di backend associato a questo output può quindi aiutare ad attribuire le azioni all’utente AD effettivo.
```
pgrole1@postgres:[615]:LOG: connection authorized: user=pgrole1 database=postgres application_name=psql GSS (authenticated=yes, encrypted=yes, principal=Admin@EXAMPLE.COM)
```
## Limitazioni
+ Microsoft Entra ID noto come Azure Active Directory non è supportato.
## Utilizzo delle funzioni dall’estensione `pg_ad_mapping`
L’estensione `pg_ad_mapping` ha fornito supporto alle seguenti funzioni:
### pgadmap\$1set\$1mapping
Questa funzione stabilisce la mappatura tra il gruppo di sicurezza AD e il ruolo di database con un peso associato.
#### Sintassi
```
pgadmap_set_mapping(
ad_group,
db_role,
ad_group_sid,
weight)
```
#### Arguments (Argomenti)
| Parametro | Description |
| --- | --- |
| ad\$1group | Nome del gruppo AD. Il valore non può essere null o una stringa vuota. |
| db\$1role | Ruolo di database da mappare al gruppo AD specificato. Il valore non può essere null o una stringa vuota. |
| ad\$1group\$1sid | Identificatore di sicurezza utilizzato per identificare in modo univoco il gruppo AD. Il valore inizia con ‘S-1-’ e non può essere null o una stringa vuota. Per ulteriori informazioni, consulta [Recupero del SID del gruppo Active Directory in PowerShell](#AD.Security.Groups.retrieving). |
| peso | Peso associato al ruolo di database. Il ruolo con il peso più elevato ha la precedenza quando l’utente è membro di più gruppi. Il valore predefinito del peso è 1. |
#### Tipo restituito
`None`
#### Note per l’utilizzo
Questa funzione aggiunge una nuova mappatura dal gruppo di sicurezza AD al ruolo di database. Può essere eseguito solo sull’istanza database primaria del cluster di database da un utente con il privilegio rds\$1superuser.
#### Esempi
```
postgres=> select pgadmap_set_mapping('accounts-group','accounts-role','S-1-2-33-12345-67890-12345-678',10);
pgadmap_set_mapping
(1 row)
```
### pgadmap\$1read\$1mapping
Questa funzione elenca le mappature tra il gruppo di sicurezza AD e il ruolo di database che sono state impostate utilizzando la funzione `pgadmap_set_mapping`.
#### Sintassi
```
pgadmap_read_mapping()
```
#### Arguments (Argomenti)
`None`
#### Tipo restituito
| Parametro | Description |
| --- | --- |
| ad\$1group\$1sid | Identificatore di sicurezza utilizzato per identificare in modo univoco il gruppo AD. Il valore inizia con ‘S-1-’ e non può essere null o una stringa vuota. Per ulteriori informazioni, consulta [Recupero del SID del gruppo Active Directory in PowerShell](#AD.Security.Groups.retrieving).accounts-role@example.com |
| db\$1role | Ruolo di database da mappare al gruppo AD specificato. Il valore non può essere null o una stringa vuota. |
| peso | Peso associato al ruolo di database. Il ruolo con il peso più elevato ha la precedenza quando l’utente è membro di più gruppi. Il valore predefinito del peso è 1. |
| ad\$1group | Nome del gruppo AD. Il valore non può essere null o una stringa vuota. |
#### Note per l’utilizzo
Chiama questa funzione per elencare tutte le mappature disponibili tra il gruppo di sicurezza AD e il ruolo di database.
#### Esempi
```
postgres=> select * from pgadmap_read_mapping();
ad_sid | pg_role | weight | ad_grp
------------------------------------+---------------+--------+------------------
S-1-2-33-12345-67890-12345-678 | accounts-role | 10 | accounts-group
(1 row)
(1 row)
```
### pgadmap\$1reset\$1mapping
Questa funzione ripristina una o tutte le mappature impostate con la funzione `pgadmap_set_mapping`.
#### Sintassi
```
pgadmap_reset_mapping(
ad_group_sid,
db_role,
weight)
```
#### Arguments (Argomenti)
| Parametro | Description |
| --- | --- |
| ad\$1group\$1sid | Identificatore di sicurezza utilizzato per identificare in modo univoco il gruppo AD. |
| db\$1role | Ruolo di database da mappare al gruppo AD specificato. |
| peso | Peso associato al ruolo di database. |
Se non vengono forniti argomenti, tutte le mappature dei gruppi AD ai ruoli di database vengono reimpostate. È necessario fornire tutti gli argomenti o nessuno.
#### Tipo restituito
`None`
#### Note per l’utilizzo
Chiama questa funzione per eliminare uno specifico gruppo AD nella mappatura dei ruoli di database o per ripristinare tutte le mappature. Questa funzione può essere eseguita solo sull’istanza database primaria del cluster di database da un utente con il privilegio `rds_superuser`.
#### Esempi
```
postgres=> select * from pgadmap_read_mapping();
ad_sid | pg_role | weight | ad_grp
--------------------------------+--------------+-------------+-------------------
S-1-2-33-12345-67890-12345-678 | accounts-role| 10 | accounts-group
S-1-2-33-12345-67890-12345-666 | sales-role | 10 | sales-group
(2 rows)
postgres=> select pgadmap_reset_mapping('S-1-2-33-12345-67890-12345-678', 'accounts-role', 10);
pgadmap_reset_mapping
(1 row)
postgres=> select * from pgadmap_read_mapping();
ad_sid | pg_role | weight | ad_grp
--------------------------------+--------------+-------------+---------------
S-1-2-33-12345-67890-12345-666 | sales-role | 10 | sales-group
(1 row)
postgres=> select pgadmap_reset_mapping();
pgadmap_reset_mapping
(1 row)
postgres=> select * from pgadmap_read_mapping();
ad_sid | pg_role | weight | ad_grp
--------------------------------+--------------+-------------+--------------
(0 rows)
```