Usa Microsoft Active Directory con Autonomous Database sull'infrastruttura Exadata dedicata

Prerequisiti per configurare CMU con Microsoft Active Directory su Autonomous Database

Di seguito sono riportati i prerequisiti necessari per configurare la connessione da Autonomous Database ad Active Directory.

Microsoft Active Directory deve essere installato e configurato. Per ulteriori informazioni, vedere AD DS Getting Started.
È necessario creare un utente della directory dei servizi Oracle in Active Directory. Per informazioni sull'account utente della directory dei servizi Oracle, vedere il Passo 1: Creare un account utente di Oracle Service Directory su Microsoft Active Directory e concedere le autorizzazioni nel manuale Oracle Database 19c Security Guide o nel manuale Oracle Database 23ai Security Guide.
Un amministratore di sistema di Active Directory deve aver installato il filtro password Oracle sui server Active Directory e impostare i gruppi di Active Directory con gli utenti di Active Directory per soddisfare i requisiti.

Solo l'autenticazione con password è supportata con CMU per Autonomous Database. Pertanto, è necessario utilizzare la utility inclusa, opwdintg.exe, per installare il filtro password Oracle su Active Directory, estendere lo schema e creare tre nuovi gruppi ORA_VFR per tre tipi di generazione del verificatore password. Per informazioni sull'installazione del filtro password Oracle, vedere il Passo 2: Per l'autenticazione con password, installare il filtro password ed estendere lo schema Microsoft Active Directory nel manuale Oracle Database 19c Security Guide o nel manuale Oracle Database 23ai Security Guide.
I server Active Directory devono essere accessibili da Autonomous Database tramite la rete Internet pubblica e la porta 636 dei server Active Directory deve essere aperta ad Autonomous Database in Oracle Cloud Infrastructure, in modo che Autonomous Database possa avere un accesso LDAP protetto su TLS/SSL ai server Active Directory tramite Internet.

È inoltre possibile estendere Active Directory in locale a Oracle Cloud Infrastructure, in cui è possibile impostare i controller di dominio di sola lettura (RODC) per l'Active Directory in locale. È quindi possibile utilizzare questi RODC in Oracle Cloud Infrastructure per autenticare e autorizzare gli utenti Active Directory on premise per l'accesso agli Autonomous Database.

Per ulteriori informazioni, vedere Estendere l'integrazione di Active Directory nel cloud ibrido.
Per configurare CMU per Autonomous Database, è necessario il wallet del database di configurazione CMU, cwallet.sso e il file di configurazione CMU dsi.ora:
- Se si è configurato CMU per un database in locale, è possibile ottenere questi file di configurazione dal database server in locale.
- Se non si è configurato CMU per un database in locale, è necessario creare questi file. Quindi, carica i file di configurazione nel cloud per configurare CMU nell'istanza di Autonomous Database. È possibile convalidare il wallet e il file dsi.ora configurando CMU per un database in locale e verificando che un utente di Active Directory possa eseguire correttamente il login al database in locale con questi file di configurazione. Quindi carica questi file di configurazione nel cloud per configurare CMU per l'Autonomous Database.
Per i dettagli sul file wallet per CMU, vedere:
- Passo 6: Creare il wallet per una connessione sicura nel manuale Oracle Database 19c Security Guide o nel manuale Oracle Database 23ai Security Guide
- Passo 8: verificare Oracle Wallet nel manuale Oracle Database 19c Security Guide e nel manuale Oracle Database 23ai Security Guide.
Per informazioni dettagliate sul file dsi.ora per la utility CMU, vedere Creating the dsi.ora File in Oracle Database 19c Security Guide o Oracle Database 23ai Security Guide.

Per informazioni dettagliate sulla configurazione di Active Directory per CMU e sulla risoluzione dei problemi CMU per i database in locale, vedere Come configurare gli utenti gestiti a livello centrale per le release del database 18c o successive (ID documento 2462012.1).

Configurare CMU con Microsoft Active Directory su Autonomous Database

Per configurare Autonomous Database per CMU per la connessione ai server Active Directory, effettuare le operazioni riportate di seguito.

Eseguire la connessione ad Autonomous Database come utente ADMIN.
Verificare se nel database è abilitato un altro schema di autenticazione esterno e disabilitarlo.

Nota
È possibile continuare con la configurazione CMU-AD sopra Kerberos per fornire l'autenticazione Kerberos CMU-AD per gli utenti di Microsoft Active Directory.
Caricare i file di configurazione CMU, inclusi il file wallet del database, cwallet.sso e il file di configurazione CMU, dsi.ora nell'area di memorizzazione degli oggetti. Questo passo dipende dall'area di memorizzazione degli oggetti utilizzata.

Il file di configurazione dsi.ora contiene le informazioni per trovare i server Active Directory.

Se si utilizza l'area di memorizzazione degli oggetti Oracle Cloud Infrastructure, vedere Inserimento dei dati nello storage degli oggetti per i dettagli sul caricamento dei file.
In Autonomous Database, creare un nuovo oggetto directory o scegliere un oggetto directory esistente. Questa è la directory in cui vengono memorizzati il wallet e il file di configurazione per la connessione ad Active Directory:
Ad esempio:
```
CREATE OR REPLACE DIRECTORY cmu_wallet_dir AS 'cmu_wallet';
```
Utilizzare l'istruzione SQL seguente per eseguire una query sul percorso della directory del file system dell'oggetto directory:
```
SELECT DIRECTORY_PATH FROM DBA_DIRECTORIES WHERE 
   DIRECTORY_NAME='directory_object_name';
```
Ad esempio:
```
SELECT DIRECTORY_PATH FROM DBA_DIRECTORIES WHERE 
   DIRECTORY_NAME='CMU_WALLET_DIR';


DIRECTORY_PATH
----------------------------------------------------------------------------
/file_system_directory_path_example/cmu_wallet
```
Nota
Il nome dell'oggetto directory nella query deve essere maiuscolo poiché il relativo caso non è stato conservato al momento della creazione dell'oggetto directory.
Se si desidera preservare la distinzione tra maiuscole e minuscole per il nome dell'oggetto directory, è necessario includerne il nome tra virgolette. Ad esempio:
```
CREATE OR REPLACE DIRECTORY "CMU_wallet_dir" AS 'cmu_wallet';
```
Utilizzare DBMS_CLOUD.GET_OBJECT per copiare i file di configurazione CMU, il wallet del database cwallet.sso e dsi.ora, dall'area di memorizzazione degli oggetti alla directory creata o scelta nel passo 4 precedente.
Ad esempio, utilizzare DBMS_CLOUD.GET_OBJECT per copiare i file dall'area di memorizzazione degli oggetti a CMU_WALLET_DIR come indicato di seguito.
```
BEGIN
   DBMS_CLOUD.GET_OBJECT(
      credential_name => 'DEF_CRED_NAME',
      object_uri => 'https://objectstorage.us-phoenix-1.oraclecloud.com/n/namespace-string/b/bucketname/o/cwallet.sso',
      directory_name => 'CMU_WALLET_DIR');
   DBMS_CLOUD.GET_OBJECT(
      credential_name => 'DEF_CRED_NAME',
      object_uri => 'https://objectstorage.us-phoenix-1.oraclecloud.com/n/namespace-string/b/bucketname/o/dsi.ora',
      directory_name => 'CMU_WALLET_DIR');
END;
/
```
In questo esempio, namespace-string è lo spazio di nomi dello storage degli oggetti Oracle Cloud Infrastructure e bucketname è il nome del bucket. Per ulteriori informazioni, vedere Informazioni sugli spazi di nomi dello storage degli oggetti.
Per ulteriori informazioni, vedere GET_OBJECT Procedura.
Utilizzare l'istruzione SQL seguente per eseguire una query sui file copiati nella directory.
```
SELECT * FROM DBMS_CLOUD.LIST_FILES('directory_object_name');
```
Ad esempio:
```
SELECT * FROM DBMS_CLOUD.LIST_FILES('CMU_WALLET_DIR');
```
Tenere presente che il nome dell'oggetto directory in questa query deve essere maiuscolo poiché il relativo caso non è stato conservato al momento della creazione dell'oggetto directory.
Abilita CMU-AD nel tuo Autonomous Database utilizzando il pacchetto DBMS_CLOUD_ADMIN.
Nota
Sostituire i nomi delle directory nell'esempio seguente con quelli scelti per l'ambiente in uso. Assicurarsi di aver eseguito il login come utente ADMIN prima di eseguire questo comando.
```
BEGIN
  DBMS_CLOUD_ADMIN.ENABLE_EXTERNAL_AUTHENTICATION(
    type     => 'CMU',
    params   => JSON_OBJECT('directory_name' value 'CMU_WALLET_DIR')
  ); 
END;
/ 
```
Per mantenere la sicurezza, rimuovere i file di configurazione CMU, inclusi il wallet del database cwallet.sso e il file di configurazione CMU dsi.ora dall'area di memorizzazione degli oggetti. È possibile utilizzare i metodi dell'area di memorizzazione degli oggetti locale per rimuovere questi file oppure utilizzare DBMS_CLOUD.DELETE_OBJECT per eliminare i file dall'area di memorizzazione degli oggetti.
Per ulteriori informazioni su DELETE_OBJECT Procedura, vedere DBMS_CLOUD.DELETE_OBJECT.

Nota

Per istruzioni sulla disabilitazione dell'accesso da Autonomous Database ad Autonomous Database, vedere Disabilita accesso Active Directory ad Active Directory.

Per ulteriori informazioni, vedere Configuring Centrally Managed Users with Microsoft Active Directory nel manuale Oracle Database 19c Security Guide o nel manuale Oracle Database 19c Security Guide.

Configurare CMU con Microsoft Active Directory su Exadata Cloud@Customer

SI APPLICA A: solo Exadata Cloud@Customer

Per configurare Autonomous Database su Exadata Cloud@Customer per consentire a CMU di connettersi ai server Active Directory, senza utilizzare il servizio Oracle Object Store:

Eseguire la connessione ad Autonomous Database come utente ADMIN.
Verificare se nel database è abilitato un altro schema di autenticazione esterno e disabilitarlo utilizzando il seguente comando SQL.
```
BEGIN
  DBMS_CLOUD_ADMIN.DISABLE_EXTERNAL_AUTHENTICATION;
END;
/
```
CMU-AD richiede il wallet di connessione Active Directory cwallet.sso e i file dsi.ora in un file system locale nel cluster VM Autonomous Exadata (AVMC). Per ottenere questo risultato, è possibile ospitare questi file nel servizio Oracle Object Store su Oracle Cloud Infrastructure e copiarli localmente utilizzando il pacchetto DBMS_CLOUD. È possibile trovare questo processo con passi ed esempi dettagliati in Configura CMU con Microsoft Active Directory su Autonomous Database.
Se l'hosting di cwallet.sso e dsi.ora nello storage cloud non è possibile, è possibile utilizzare una condivisione NFS (Network File System) nel data center per ospitare questi file, quindi spostarli in una directory di database sotto il file system del database (DBFS). A tale scopo, è innanzitutto necessario collegare una condivisione NFS disponibile localmente all'oggetto directory di Autonomous Database, come illustrato di seguito:
1. Creare una directory di database nell'istanza di Autonomous Database utilizzando il seguente comando SQL dal client SQL:
```
create or replace directory TMPFSSDIR as 'tmpfssdir';
```
2. Attivare la condivisione NFS in questa directory utilizzando il package DBMS_CLOUD_ADMIN disponibile in Autonomous Database.
  
  Suggerimento
  Potrebbe essere necessario collaborare con l'amministratore della rete o dello storage per rendere disponibile una condivisione NFS.
```
BEGIN
  DBMS_CLOUD_ADMIN.attach_file_system(
    file_system_name => <some_name_you_assign>,
    file_system_location => <your_nfs_fs_path>,
    directory_name => <tmpfssdir_created_above>,
    description => ‘Any_desc_you_like_to_give’
  );
END
```
  Ad esempio:
```
BEGIN 
  DBMS_CLOUD_ADMIN.attach_file_system(
    file_system_name => 'AD-FSS',
    file_system_location => acme.com:/nfs/mount1',
    directory_name => 'TMPFSSDIR',
    description => ‘nfs to host AD files’
  );
END;
```

Per evitare una dipendenza dalla condivisione NFS per i file cwallet.sso e dsi.ora disponibili per CMU, spostarli in una cartella di file system locale utilizzando un mapping di directory del database. Poiché Autonomous Database limita l'accesso al file system locale, creare una procedura di copia utilizzando utl_file come mostrato di seguito:

Creare una directory di database nell'istanza di Autonomous Database utilizzando il seguente comando SQL dal client SQL:
```
CREATE OR REPLACE DIRECTORY cmu_wallet_dir AS 'cmu_wallet';
```
Controllare il percorso della directory creata sopra utilizzando il seguente comando SQL:
```
SELECT DIRECTORY_PATH 
FROM DBA_DIRECTORIES 
WHERE DIRECTORY_NAME ='CMU_WALLET_DIR';
```
Nota
Il nome dell'oggetto directory deve essere in lettere maiuscole nella query, poiché il relativo caso non è stato conservato durante la creazione dell'oggetto directory.

Copiare dsi.ora e cwallet.sso dalla directory NFS nella directory del wallet CMU locale utilizzando la utility UTL_FILE.

Ad esempio:

Creare una stored procedure denominata copyfile come mostrato di seguito:

CREATE OR REPLACE PROCEDURE copyfile(
  in_loc_dir IN VARCHAR2,
  in_filename IN VARCHAR2,
  out_loc_dir IN VARCHAR2,
  out_filename IN VARCHAR2
)
IS
  in_file UTL_FILE.file_type;
  out_file UTL_FILE.file_type;
  buffer_size CONSTANT INTEGER := 32767;
  buffer RAW (32767);
  buffer_length INTEGER; 
BEGIN
  in_file := UTL_FILE.fopen (in_loc_dir, in_filename, 'rb', buffer_size);
  out_file := UTL_FILE.fopen (out_loc_dir, out_filename, 'wb', buffer_size);
  UTL_FILE.get_raw (in_file, buffer, buffer_size);
  buffer_length := UTL_RAW.LENGTH (buffer);

  WHILE buffer_length > 0
  LOOP 
    UTL_FILE.put_raw (out_file, buffer, TRUE);

    IF buffer_length = buffer_size
      THEN
        UTL_FILE.get_raw (in_file, buffer, buffer_size);
        buffer_length := UTL_RAW.LENGTH (buffer);
      ELSE
        buffer_length := 0;
      END IF;
  END LOOP;

  UTL_FILE.fclose (in_file);
  UTL_FILE.fclose (out_file);
EXCEPTION
  WHEN NO_DATA_FOUND
  THEN
    UTL_FILE.fclose (in_file);
    UTL_FILE.fclose (out_file);
END;
/

Compilare la stored procedure copyfile. Una volta compilata correttamente, eseguire la procedura copyfile una volta per volta per copiare dsi.ora e cwallet.sso dalla directory NFS alla directory del wallet CMU locale, come mostrato di seguito:

EXEC copyfile('TMPFSSDIR','dsi.ora','CMU_WALLET_DIR','dsi.ora');

EXEC copyfile('TMPFSSDIR','cwallet.sso','CMU_WALLET_DIR','cwallet.sso');

Eseguire la query SQL seguente per verificare se i file vengono copiati correttamente nella directory del wallet CMU locale.
```
SELECT * FROM DBMS_CLOUD.LIST_FILES('CMU_WALLET_DIR');
```

Con il comando seguente, scollegare la condivisione NFS in quanto non è necessaria per CMU-AD dopo la copia dei file nella directory locale.
```
exec DBMS_CLOUD_ADMIN.detach_file_system(file_system_name => <FILE_SYSTEM_NAME>);
```
Abilita CMU-AD nel tuo Autonomous Database utilizzando il pacchetto DBMS_CLOUD_ADMIN.
Nota
Sostituire i nomi delle directory nell'esempio seguente con quelli scelti per l'ambiente in uso. Assicurarsi di aver eseguito il login come utente ADMIN prima di eseguire questo comando.
```
BEGIN
  DBMS_CLOUD_ADMIN.ENABLE_EXTERNAL_AUTHENTICATION(
    type     => 'CMU',
    params   => JSON_OBJECT('directory_name' value 'CMU_WALLET_DIR')
  ); 
END;
/ 
```

Eseguire la convalida eseguendo una query sul valore della proprietà del database CMU_WALLET come mostrato di seguito.

SELECT PROPERTY_VALUE
FROM DATABASE_PROPERTIES
WHERE PROPERTY_NAME = 'CMU_WALLET';

Ad esempio:

SELECT PROPERTY_VALUE
FROM DATABASE_PROPERTIES
WHERE PROPERTY_NAME='CMU_WALLET';

PROPERTY_VALUE
--------------
CMU_WALLET_DIR

È ora stato configurato CMU-AD per utilizzare l'autenticazione esterna tramite Microsoft Active Directory con l'Autonomous Database su Exadata Cloud@Customer.

Aggiungi ruoli Microsoft Active Directory su Autonomous Database

Per aggiungere ruoli Active Directory, mappare i ruoli globali del database ai gruppi Active Directory con le istruzioni CREATE ROLE o ALTER ROLE e includere la clausola IDENTIFIED GLOBALLY AS.

Per aggiungere ruoli globali per i gruppi Active Directory in Autonomous Database, procedere come segue.

Eseguire il login come utente ADMIN al database configurato per l'utilizzo di Active Directory (l'utente ADMIN dispone dei privilegi di sistema CREATE ROLE e ALTER ROLE necessari per questi passi).
Impostare l'autorizzazione del database per i ruoli di Autonomous Database con l'istruzione CREATE ROLE o ALTER ROLE. Includere la clausola IDENTIFIED GLOBALLY AS e specificare il DN di un gruppo Active Directory.
Utilizzare la sintassi seguente per mappare un gruppo di utenti di directory a un ruolo globale del database:
```
CREATE ROLE global_role IDENTIFIED GLOBALLY AS 
     'DN_of_an_AD_GROUP_of_WHICH_the_AD_USER_IS_a_MEMBER';
```
Ad esempio:
```
CREATE ROLE widget_sales_role IDENTIFIED GLOBALLY AS
     'CN=widget_sales_group,OU=sales,DC=production,DC=example,DC=com';
```
In questo esempio tutti i membri di widget_sales_group sono autorizzati con il ruolo di database widget_sales_role quando eseguono il login al database.
Utilizzare le istruzioni GRANT per concedere i privilegi o altri ruoli richiesti al ruolo globale.
Ad esempio:
```
GRANT CREATE SESSION TO WIDGET_SALES_ROLE;
GRANT DWROLE TO WIDGET_SALES_ROLE;
```
DWROLE è un ruolo predefinito con privilegi comuni definiti. Per informazioni sull'impostazione dei privilegi comuni per gli utenti di Autonomous Database, vedere Gestisci privilegi utente database.
Se si desidera associare un ruolo di database esistente a un gruppo Active Directory, utilizzare l'istruzione ALTER ROLE per modificare il ruolo di database esistente per mappare il ruolo a un gruppo Active Directory.
Utilizzare la seguente sintassi per modificare un ruolo di database esistente per mapparlo a un gruppo Active Directory:
```
ALTER ROLE existing_database_role 
   IDENTIFIED GLOBALLY AS 'DN_of_an_AD_GROUP_of_WHICH_the_AD_USER_IS_a_MEMBER';
```
Se si desidera creare mapping di ruoli globali aggiuntivi per altri gruppi Active Directory, attenersi alla procedura riportata di seguito per ogni gruppo Active Directory.

Per ulteriori informazioni sulla configurazione dei ruoli con Microsoft Active Directory, vedere Configuring Authorization for Centrally Managed Users nella Oracle Database 19c Security Guide o nella Oracle Database 23ai Security Guide.

Aggiungi utenti Microsoft Active Directory su Autonomous Database

Per aggiungere utenti Active Directory per accedere a un Autonomous Database, mappare gli utenti globali del database ai gruppi o agli utenti Active Directory con istruzioni CREATE USER o ALTER USER (con la clausola IDENTIFIED GLOBALLY AS).

L'integrazione di Autonomous Database con Active Directory funziona mediante il mapping diretto di utenti e gruppi di Microsoft Active Directory agli utenti globali e ai ruoli globali del database Oracle.

Per aggiungere utenti globali per gruppi o utenti di Active Directory in Autonomous Database, procedere come segue.

Eseguire il login come utente ADMIN al database configurato per l'utilizzo di Active Directory (l'utente ADMIN dispone dei privilegi di sistema CREATE USER e ALTER USER necessari per questi passi).
Impostare l'autorizzazione del database per gli utenti di Autonomous Database con le istruzioni CREATE USER o ALTER USER e includere la clausola IDENTIFIED GLOBALLY AS, specificando il DN di un utente o di un gruppo Active Directory.
Utilizzare la sintassi seguente per mappare un utente di directory a un utente globale del database:
```
CREATE USER global_user IDENTIFIED GLOBALLY AS 'DN_of_an_AD_USER';
```
Utilizzare la sintassi seguente per mappare un gruppo di directory a un utente globale del database:
```
CREATE USER global_user IDENTIFIED GLOBALLY AS
    'DN_of_an_AD_GROUP_of_WHICH_the_AD_USER_IS_a_MEMBER';
```
Ad esempio, per mappare un gruppo di directory denominato widget_sales_group nell'unità organizzativa sales del dominio production.example.com a un utente globale del database condiviso denominato WIDGET_SALES:
```
CREATE USER widget_sales IDENTIFIED GLOBALLY AS
     'CN=widget_sales_group,OU=sales,DC=production,DC=example,DC=com';
```
Questo crea un mapping utenti globale condiviso. Il mapping, con l'utente globale widget_sales, è valido per tutti gli utenti del gruppo Active Directory. Pertanto, chiunque nel file widget_sales_group può eseguire il login al database utilizzando le proprie credenziali Active Directory (attraverso il mapping condiviso dell'utente globale widget_sales).
Se si desidera che gli utenti di Active Directory utilizzino un utente di database esistente, ne possiedano lo schema e possiedano i dati esistenti, utilizzare ALTER USER per modificare un utente di database esistente per mappare l'utente a un gruppo o a un utente di Active Directory.
- Utilizzare la seguente sintassi per modificare un utente di database esistente per mapparlo a un utente di Active Directory:
```
ALTER USER existing_database_user IDENTIFIED GLOBALLY AS 'DN_of_an_AD_USER';
```
- Utilizzare la seguente sintassi per modificare un utente di database esistente per mapparlo a un gruppo Active Directory:
```
ALTER USER existing_database_user 
     IDENTIFIED GLOBALLY AS 'DN_of_an_AD_GROUP_of_WHICH_the_AD_USER_IS_a_MEMBER';
```
Se si desidera creare mapping utente globali aggiuntivi per altri gruppi o utenti di Active Directory, attenersi alla procedura riportata di seguito per ogni gruppo o utente di Active Directory.

Per ulteriori informazioni sulla configurazione dei ruoli con Microsoft Active Directory, vedere Configuring Authorization for Centrally Managed Users nella Oracle Database 19c Security Guide o nella Oracle Database 23ai Security Guide.

Connettersi ad Autonomous Database con le credenziali utente di Active Directory

Dopo che l'utente ADMIN ha completato i passi di configurazione di CMU Active Directory e ha creato ruoli globali e utenti globali, gli utenti eseguono il login ad Autonomous Database utilizzando il nome utente e la password di Active Directory.

Nota

Non eseguire il login utilizzando un nome utente globale. I nomi utente globali non dispongono di una password e la connessione con un nome utente globale non riuscirà. Per eseguire il login al database, è necessario disporre di un mapping utenti globale in Autonomous Database. Impossibile eseguire il login al database con solo mapping di ruoli globali.

Per eseguire il login ad Autonomous Database utilizzando un nome utente e una password Active Directory, effettuare la connessione come indicato di seguito.
```
CONNECT "AD_DOMAIN\AD_USERNAME"/AD_USER_PASSWORD@TNS_ALIAS_OF_THE_AUTONOMOUS_DATABASE;
```
Ad esempio:
```
CONNECT "production\pfitch"/password@adbname_medium;
```
È necessario includere le virgolette doppie quando il dominio Active Directory viene incluso insieme al nome utente, come nell'esempio seguente: "production\pfitch".

In questo esempio, il nome utente di Active Directory è pfitch nel dominio production. L'utente Active Directory è un membro del gruppo widget_sales_group identificato dal relativo DN 'CN=widget_sales_group,OU=sales,DC=production,DC=example,DC=com'.

Dopo aver configurato CMU con Active Directory in Autonomous Database e aver impostato l'autorizzazione Active Directory, con ruoli globali e utenti globali, è possibile connettersi a Autonomous Database utilizzando uno dei metodi di connessione descritti in Informazioni sulla connessione a un Autonomous Database dedicato. Quando ci si connette, se si desidera utilizzare un utente di Active Directory, utilizzare le credenziali utente di Active Directory. Ad esempio, fornire un nome utente nel formato "AD_DOMAIN\AD_USERNAME" (devono essere incluse le virgolette doppie) e utilizzare AD_USER_PASSWORD per la password.

Verificare le informazioni sulla connessione utente Active Directory con Autonomous Database

Quando gli utenti eseguono il login ad Autonomous Database utilizzando il nome utente e la password di Active Directory, è possibile verificare ed eseguire l'audit dell'attività utente.

Ad esempio, quando l'utente pfitch esegue il login:

CONNECT "production\pfitch"/password@exampleadb_medium;

Il nome utente di login dell'utente Active Directory (samAccountName) è pfitch e widget_sales_group è il nome del gruppo Active Directory e widget_sales è l'utente globale di Autonomous Database.

Dopo aver eseguito il login al database con pfitch, il comando SHOW USER mostra il nome utente globale:

SHOW USER;

USER is "WIDGET_SALES"

Il comando seguente mostra il DN (Distinguished Name) dell'utente di Active Directory:

SELECT SYS_CONTEXT('USERENV', 'ENTERPRISE_IDENTITY') FROM DUAL;

Ad esempio, è possibile verificare l'identità aziendale di questo utente gestito centralmente:

SQL> SELECT SYS_CONTEXT('USERENV', 'ENTERPRISE_IDENTITY') FROM DUAL;

SYS_CONTEXT('USERENV','ENTERPRISE_IDENTITY')
----------------------------------------------------------------------
cn=Peter Fitch,ou=sales,dc=production,dc=examplecorp,dc=com

Il comando seguente mostra "AD_DOMAIN\AD_USERNAME":

SELECT SYS_CONTEXT('USERENV', 'AUTHENTICATED_IDENTITY') FROM DUAL;

Ad esempio, l'identità utente autenticata di Active Directory viene acquisita e sottoposta ad audit quando l'utente accede al database:

SQL> SELECT SYS_CONTEXT('USERENV', 'AUTHENTICATED_IDENTITY') FROM DUAL;

SYS_CONTEXT('USERENV','AUTHENTICATED_IDENTITY')
----------------------------------------------------------------------
production\pfitch

Per ulteriori informazioni, vedere Verifying the Centrally Managed User Logon Information in Oracle Database 19c Security Guide o Oracle Database 23ai Security Guide.

Rimuovi utenti e ruoli di Active Directory in Autonomous Database

Per rimuovere utenti e ruoli di Active Directory dagli Autonomous Database, utilizzare i comandi di database standard. Questa operazione non rimuove gli utenti o i gruppi correlati di Active Directory mappati dagli utenti o dai ruoli del database eliminati.

Per rimuovere utenti o ruoli da Autonomous Database, effettuare le operazioni riportate di seguito.

Eseguire il login al database configurato per utilizzare Active Directory come utente a cui è stato concesso il privilegio di sistema DROP USER o DROP ROLE.
Eliminare gli utenti globali o i ruoli globali mappati ai gruppi o agli utenti di Active Directory con l'istruzione DROP USER o DROP ROLE.
Per ulteriori informazioni, vedere Rimuovi utenti del database.

Disabilita accesso a Active Directory su Autonomous Database

Descrive i passi per rimuovere la configurazione CMU da Autonomous Database (e disabilitare l'accesso LDAP da Autonomous Database ad Active Directory).

Dopo aver configurato l'istanza di Autonomous Database per accedere ad Active Directory CMU, è possibile disabilitare l'accesso come indicato di seguito.

Eseguire la connessione ad Autonomous Database come utente ADMIN.
Utilizzare DBMS_CLOUD_ADMIN.DISABLE_EXTERNAL_AUTHENTICATION per disabilitare l'autenticazione CMU.

Nota
Per eseguire questa procedura, è necessario eseguire il login come utente ADMIN o disporre del privilegio EXECUTE su DBMS_CLOUD_ADMIN.
Ad esempio:
```
BEGIN   
   DBMS_CLOUD_ADMIN.DISABLE_EXTERNAL_AUTHENTICATION;
END;
/
```
Questa operazione disabilita l'autenticazione CMU nell'istanza di Autonomous Database.

Per ulteriori informazioni, vedere DISABLE_EXTERNAL_AUTHENTICATION Procedura.

Limitazioni con Microsoft Active Directory su Autonomous Database

Le seguenti limitazioni si applicano a CMU con Active Directory su Autonomous Database:

Per CMU con Autonomous Database sono supportati solo l'autenticazione con password e Kerberos. Quando si utilizza l'autenticazione CMU con Autonomous Database, non sono supportati altri metodi di autenticazione come Azure AD, OCI IAM e PKI.
Oracle Application Express e Database Actions non sono supportati per gli utenti Active Directory con Autonomous Database.