Usa Microsoft Active Directory con Autonomous AI Database su un'infrastruttura Exadata dedicata

Prerequisiti per configurare CMU con Microsoft Active Directory su Autonomous AI Database

Di seguito sono riportati i prerequisiti necessari per configurare la connessione da Autonomous AI 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 di servizio Oracle in Active Directory. Per informazioni sull'account utente della directory dei servizi Oracle, vedere il Passo 1: Create an Oracle Service Directory User Account on Microsoft Active Directory and Grant Permissions in Oracle Database 19c Security Guide o Oracle Database 26ai 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 della password è supportata con CMU per Autonomous AI Database, quindi è necessario utilizzare la utility inclusa, opwdintg.exe, per installare il filtro delle password Oracle su Active Directory, estendere lo schema e creare tre nuovi gruppi ORA_VFR per tre tipi di generazione del verificatore delle password. Per informazioni sull'installazione del filtro delle password Oracle, vedere Passo 2: per l'autenticazione delle password, installare il filtro delle password ed estendere lo schema di Microsoft Active Directory in Oracle Database 19c Security Guide o Oracle Database 26ai Security Guide.
I server Active Directory devono essere accessibili da Autonomous AI Database tramite la rete Internet pubblica e la porta 636 dei server Active Directory deve essere aperta a Autonomous AI Database in Oracle Cloud Infrastructure, in modo che Autonomous AI Database possa aver protetto l'accesso LDAP tramite TLS/SSL AI server Active Directory tramite Internet.

È inoltre possibile estendere Active Directory on-premise a Oracle Cloud Infrastructure, dove è possibile impostare i controller di dominio di sola lettura (RODC) per Active Directory on-premise. Quindi puoi utilizzare questi RODC in Oracle Cloud Infrastructure per autenticare e autorizzare gli utenti Active Directory on-premise per l'accesso AI database AI Autonomous.

Per ulteriori informazioni, vedere Estendere l'integrazione di Active Directory nel cloud ibrido.
Per configurare CMU per il database AI autonomo, è 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 hai configurato CMU per un database in locale, devi creare questi file. Quindi carichi i file di configurazione nel cloud per configurare CMU nell'istanza di Autonomous AI Database. È possibile convalidare il wallet e 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 carichi questi file di configurazione nel cloud per configurare CMU per il tuo database AI autonomo.
Per i dettagli sul file wallet per CMU, vedere:
- Passo 6: Creare il wallet per una connessione sicura in Oracle Database 19c Security Guide o Oracle Database 26ai Security Guide
- Passo 8: verificare Oracle Wallet in Oracle Database 19c Security Guide e Oracle Database 26ai Security Guide.
Per informazioni dettagliate sul file dsi.ora per CMU, vedere Creating the dsi.ora File in Oracle Database 19c Security Guide o Oracle Database 26ai 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 nel database AI autonomo

Per configurare Autonomous AI Database affinché CMU possa connettersi AI server Active Directory, effettuare le operazioni riportate di seguito.

Connettersi al database AI autonomo 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.
Nel database AI autonomo, 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 database AI autonomo utilizzando il package 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 su come disabilitare l'accesso da Autonomous AI Database ad Active Directory, vedere Disabilita accesso ad Active Directory in Autonomous AI Database.

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

Configurare CMU con Microsoft Active Directory su Exadata Cloud@Customer

SI APPLICA A: solo Exadata Cloud@Customer

Per configurare Autonomous AI Database in Exadata Cloud@Customer affinché CMU si connetta AI server Active Directory, senza utilizzare il servizio Oracle Object Store:

Connettersi al database AI autonomo 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). Puoi ottenere questo risultato ospitando questi file nel servizio Oracle Object Store su Oracle Cloud Infrastructure e quindi copiandoli localmente utilizzando il package DBMS_CLOUD. È possibile trovare questo processo con passi ed esempi dettagliati in Configura CMU con Microsoft Active Directory su Autonomous AI 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 nel file system del database (DBFS). A tale scopo, è innanzitutto necessario collegare una condivisione NFS disponibile localmente all'oggetto directory Autonomous AI Database, come dimostrato di seguito:
1. Creare una directory di database nell'istanza di Autonomous AI Database utilizzando il comando SQL seguente dal client SQL:
```
create or replace directory TMPFSSDIR as 'tmpfssdir';
```
2. Eseguire il MOUNT della condivisione NFS in questa directory utilizzando il package DBMS_CLOUD_ADMIN disponibile in Autonomous AI 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 da rendere disponibili per CMU, spostarli in una cartella di file system locale utilizzando un mapping di directory del database. Poiché Autonomous AI Database limita l'accesso al file system locale, creare una procedura di copia utilizzando utl_file come dimostrato di seguito:

Creare una directory di database nell'istanza di Autonomous AI Database utilizzando il comando SQL seguente 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 database AI autonomo utilizzando il package 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 hai configurato CMU-AD per utilizzare l'autenticazione esterna tramite Microsoft Active Directory con il tuo Autonomous AI Database su Exadata Cloud@Customer.

Aggiungi ruoli Microsoft Active Directory nel database AI autonomo

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 AI Database, effettuare le operazioni riportate di seguito.

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 AI 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 per il quale sono stati definiti privilegi comuni. Per informazioni sull'impostazione dei privilegi comuni per gli utenti di Autonomous AI 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 in Oracle Database 19c Security Guide o Oracle Database 26ai Security Guide.

Aggiungi utenti Microsoft Active Directory al database AI autonomo

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

L'integrazione di Autonomous AI Database con Active Directory funziona mappando gli utenti e i gruppi di Microsoft Active Directory direttamente agli utenti globali del database Oracle e AI ruoli globali.

Per aggiungere utenti globali per gruppi o utenti Active Directory in Autonomous AI Database, effettuare le operazioni riportate di seguito.

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 AI Database con istruzioni CREATE USER o ALTER USER e includere la clausola IDENTIFIED GLOBALLY AS, specificando il DN di un utente o di un gruppo di 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 in Oracle Database 19c Security Guide o Oracle Database 26ai Security Guide.

Connettersi a Autonomous AI Database con le credenziali utente di Active Directory

Dopo che l'utente ADMIN ha completato i passi di configurazione di Active Directory CMU e creato ruoli globali e utenti globali, gli utenti eseguono il login a Autonomous AI 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 avrà esito positivo. Per eseguire il login al database, è necessario disporre di un mapping di utenti globale nel database AI autonomo. Impossibile eseguire il login al database con solo mapping di ruoli globali.

Per eseguire il login al database AI autonomo utilizzando un nome utente e una password Active Directory, connettersi 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 AI Database e aver impostato l'autorizzazione Active Directory, con ruoli globali e utenti globali, è possibile connettersi al Autonomous AI Database utilizzando uno qualsiasi dei metodi di connessione descritti in Informazioni sulla connessione a un Autonomous AI Database dedicato. Quando ci si connette, se si desidera utilizzare un utente di Active Directory, utilizzare le credenziali utente di Active Directory. Ad esempio, specificare un nome utente nel formato "AD_DOMAIN\AD_USERNAME" (è necessario includere virgolette doppie) e utilizzare AD_USER_PASSWORD per la password.

Verifica le informazioni di connessione utente Active Directory con Autonomous AI Database

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

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

CONNECT "production\pfitch"/password@exampleadb_medium;

Il log dell'utente di Active Directory sul nome utente (samAccountName) è pfitch e widget_sales_group è il nome del gruppo Active Directory e widget_sales è l'utente globale di Autonomous AI 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 26ai Security Guide.

Rimuovi utenti e ruoli di Active Directory nel database AI autonomo

Per rimuovere utenti e ruoli di Active Directory dai database AI autonomi, utilizzare i comandi di database standard. Ciò non rimuove gli utenti o i gruppi di Active Directory correlati mappati dagli utenti o dai ruoli del database eliminati.

Per rimuovere utenti o ruoli da Autonomous AI 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.

Disabilitare l'accesso ad Active Directory nel database AI autonomo

Descrive i passi per rimuovere la configurazione CMU dal database AI autonomo e disabilitare l'accesso LDAP dal database AI autonomo ad Active Directory.

Dopo aver configurato l'istanza del database AI autonomo per accedere a Active Directory CMU, è possibile disabilitare l'accesso come indicato di seguito.

Connettersi al database AI autonomo 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;
/
```
In questo modo, l'autenticazione CMU viene disabilitata nell'istanza del database AI autonomo.

Per ulteriori informazioni, vedere DISABLE_EXTERNAL_AUTHENTICATION Procedura.

Limitazioni con Microsoft Active Directory sul database AI autonomo

Le seguenti limitazioni si applicano alla CMU con Active Directory nel database AI autonomo:

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