Note :

Authentifier Oracle Database 23ai avec Microsoft Entra ID

Présentation

Oracle Database peut être intégré à Microsoft Entra ID (anciennement Microsoft Azure Active Directory) pour permettre un accès sécurisé sans mot de passe à la base de données. Grâce à cette configuration, les utilisateurs et les services peuvent se connecter à la base de données à l'aide de leurs données d'identification Microsoft Entra ID au moyen de l'authentification unique (SSO).

L'authentification est gérée au moyen d'un jeton d'accès OAuth2 émis par Microsoft Entra ID. Ce jeton, qui inclut l'identité et les détails d'accès de l'utilisateur, est transmis à Oracle Database. Le client de base de données valide le format et l'expiration du jeton avant d'autoriser l'accès, assurant ainsi un processus de connexion sécurisé et rationalisé.

Pourquoi en avons-nous besoin?

Alors que les organisations accordent de plus en plus de priorité à la sécurité, la gestion de l'accès aux données sensibles devient cruciale. Oracle Database, en collaboration avec Microsoft Entra ID, permet une authentification sécurisée sans mots de passe, tirant parti des systèmes modernes de gestion des identités pour un contrôle d'accès transparent, évolutif et robuste. Cette intégration prend en charge un large éventail de déploiements Oracle, y compris Oracle Autonomous Database, Oracle Exadata et Oracle Base Database Service, assurant ainsi un accès cohérent et sécurisé dans différents environnements.

Clients et outils de base de données

Les applications et les outils qui prennent en charge les jetons Microsoft Entra ID peuvent authentifier les utilisateurs directement au moyen de Microsoft Entra ID et transmettre le jeton d'accès à la base de données à l'instance Oracle Database au moyen de l'API client. Les outils de base de données existants, tels que SQL*Plus, peuvent être configurés pour utiliser un jeton Microsoft Entra ID stocké dans un fichier. Le jeton peut être extrait à l'aide d'outils d'aide tels que Microsoft PowerShell, l'interface de ligne de commande Azure ou des bibliothèques telles que Microsoft Authentication Library (MSAL) et enregistré dans un emplacement de fichier spécifié. Plus tard, SQL*Plus référence ce jeton lors de l'établissement de la connexion.

Flux d'authentification d'utilisateur intra à l'aide de sqlplus

Note : Ce tutoriel utilise un script Python tirant parti de MSAL pour acquérir des jetons de sécurité. Pour plus d'informations, voir Aperçu de la bibliothèque d'authentification Microsoft (MSAL).

Ce tutoriel vous guide tout au long de la configuration de l'authentification Microsoft Entra ID pour Oracle Base Database 23ai, y compris la configuration TLS. Consultez la documentation propre à votre type de base de données : sur place, Exadata, DBaaS ou autonome. Notez que TLS est préconfiguré pour Autonomous Database. Vous pouvez donc ignorer cette étape.

Public cible

Administrateurs d'Oracle Database et administrateurs d'Oracle Cloud Infrastructure Identity and Access Management (OCI IAM).

Objectifs

Préalables

Tâche 1 : Configurer TLS pour Oracle Database 23ai

Tâche 1.1 : Préparer le système d'exploitation pour la configuration TLS

  1. Connectez-vous au serveur de base de données et passez à l'utilisateur root pour configurer le répertoire.

    [opc@db23aigrid ~]$ sudo su -

[root@db23aigrid ~]# mkdir -p /etc/ORACLE/WALLETS/oracle

[root@db23aigrid ~]# cd /etc/

[root@db23aigrid etc]# chown -R oracle:oinstall ORACLE/

  2. Obtenez le nom d'hôte en tant qu'utilisateur oracle.

    [root@db23aigrid etc]# su - oracle

[oracle@db23aigrid admin]$ hostname -f

    Exemple de sortie :

    db23aigrid.sub10121249210.dbsecvcn.oraclevcn.com

  3. Se connecter à la base de données.

    [oracle@db23aigrid admin]$ sqlplus "/as sysdba"

  4. Vérifiez le répertoire racine du portefeuille.

    SQL> show parameter wallet_root;

    Exemple de sortie :

    NAME           TYPE      VALUE
----------     ------    ----------------------------------------------------
wallet_root    string    /opt/oracle/dcs/commonstore/wallets/DB23GRID_w54_iad

  5. Vérifiez le nom et le GUID de la base de données enfichable.

    SQL> show pdbs;

    Exemple de sortie :

    CON_ID   CON_NAME      OPEN MODE      RESTRICTED
-----    --------      ---------      ----------
2        PDB$SEED      READ ONLY      NO

3        DB23GRIDPDB   READ WRITE     NO

    SQL> select guid from v$containers where name = 'DB23GRIDPDB';

    Exemple de sortie :

    GUID
-- -----------------------------
32435DD0A1EC55xxx0639400000A7225

  6. Créez des répertoires locaux pour le portefeuille et les certificats.

    [oracle@db23aigrid ~]$ mkdir -p /home/oracle/wallet_tls/certificates/rootCA

[oracle@db23aigrid ~]$ mkdir -p /home/oracle/wallet_tls/certificates/db_wallet

  7. Créez le répertoire TLS de la base de données sous le chemin racine du portefeuille à l'aide du GUID de la base de données enfichable.

    [oracle@db23aigrid ~]$ mkdir -p /opt/oracle/dcs/commonstore/wallets/DB23GRID_w54_iad/32435DDxxxxxx7E0639400000A7225/tls

  8. Mettez à jour .bashrc avec les variables d'environnement liées à TLS.

    [oracle@db23aigrid ~]$ vi ~/.bashrc

    Ajoutez ce qui suit et ajustez les valeurs en fonction de votre environnement.

    export DBUSR_SYSTEM=system
export DBUSR_PWD=QAZxswedc123##     # Wallet and Database Administrator (sys) password

export ORA_TLS_DIR=/etc/ORACLE/WALLETS/oracle
export TLS_DIR=/opt/oracle/dcs/commonstore/wallets/DB23GRID_w54_iad/32435DD0A1EC55E7E0639400000A7225/tls
export ROOT_TLS_DIR=/home/oracle/wallet_tls/certificates/rootCA
export DB_TLS_DIR=/home/oracle/wallet_tls/certificates/db_wallet

export TLS_DN=CN=db23aigrid.sub10121249210.dbsecvcn.oraclevcn.com,O=oracle,L=Austin,ST=Texas,C=US
export TLS_SAN=DNS:db23aigrid,DNS:db23aigrid.sub10121249210.dbsecvcn.oraclevcn.com,
IPV4Address:143.47.117.99

  9. Appliquez les modifications.

    [oracle@db23aigrid ~]$ . ~/.bashrc

Tâche 1.2 : Configurer le portefeuille et le certificat TLS

  1. Créez et configurez le portefeuille racine.

    1. Créez le portefeuille racine.

      [oracle@db23aigrid ~]$ orapki wallet create -wallet ${ROOT_TLS_DIR} -pwd ${DBUSR_PWD} -auto_login

    2. Affichez le contenu du portefeuille, il doit être vide.

      [oracle@db23aigrid ~]$ orapki wallet display -wallet ${ROOT_TLS_DIR}

    3. Créez le certificat auto-signé pour le portefeuille de l'autorité de certification racine.

      [oracle@db23aigrid ~]$ orapki wallet add -wallet ${ROOT_TLS_DIR} -dn $TLS_DN -keysize 2048 -sign_alg sha256 -self_signed -validity 3652 -pwd ${DBUSR_PWD} -addext_san $TLS_SAN

    4. Le répertoire doit maintenant contenir des fichiers cwallet.sso et ewallet.p12.

      ls -l ${ROOT_TLS_DIR}

    5. Affichez le contenu du portefeuille, il doit comporter un utilisateur et un certificat approuvé.

      orapki wallet display -wallet ${ROOT_TLS_DIR}

    6. Exportez le certificat approuvé de l'autorité de certification racine à utiliser pour créer le portefeuille de base de données.

      [oracle@db23aigrid ~]$ orapki wallet export -wallet ${ROOT_TLS_DIR} -dn $TLS_DN -cert ${ROOT_TLS_DIR}/rootCA.crt -pwd ${DBUSR_PWD}

    7. Voir le contenu du fichier rootCA.crt.

      cat ${ROOT_TLS_DIR}/rootCA.crt

  2. Créez et configurez le portefeuille du serveur (base de données).

    1. Créez le portefeuille de base de données.

      [oracle@db23aigrid ~]$ orapki wallet create -wallet ${DB_TLS_DIR} -pwd ${DBUSR_PWD} -auto_login

    2. Ajoutez le certificat racine approuvé au portefeuille (obtenez-le auprès de votre administrateur de certificat).

      [oracle@db23aigrid ~]$ orapki wallet add -wallet ${DB_TLS_DIR} -trusted_cert -cert ${ROOT_TLS_DIR}/rootCA.crt -pwd ${DBUSR_PWD}

    3. Créez une demande de clé privée et de certificat dans le portefeuille.

      [oracle@db23aigrid ~]$ orapki wallet add -wallet ${DB_TLS_DIR} -keysize 2048 -dn $TLS_DN -pwd ${DBUSR_PWD}-addext_san $TLS_SAN

    4. Exportez la demande de certificat pour l'obtenir signée.

      [oracle@db23aigrid ~]$ orapki wallet export -wallet ${DB_TLS_DIR} -dn $TLS_DN -request ${DB_TLS_DIR}/db23gridpdb.csr -pwd ${DBUSR_PWD}

    5. Affichez le contenu du portefeuille, il y aura une entrée sous Certificats demandés.

      orapki wallet display -wallet ${DB_TLS_DIR}

    6. Voir le contenu du fichier de demande de signature de certificat.

      cat ${DB_TLS_DIR}/db23gridpdb.csr

  3. Signez et importez le certificat du serveur.

    1. Signez le CSR à l'aide du portefeuille racine auto-signé.

      [oracle@db23aigrid ~]$ orapki cert create -wallet ${ROOT_TLS_DIR} -request ${DB_TLS_DIR}/db23gridpdb.csr -cert ${DB_TLS_DIR}/db23gridpdb-signed.crt -validity 3652 -sign_alg sha256 -pwd ${DBUSR_PWD}

    2. Voir le certificat d'utilisateur du serveur signé.

      cat ${DB_TLS_DIR}/db23gridpdb-signed.crt

    3. Importez le certificat d'utilisateur du serveur de base de données signé dans le portefeuille de base de données.

      [oracle@db23aigrid ~]$ orapki wallet add -wallet ${DB_TLS_DIR} -user_cert -cert ${DB_TLS_DIR}/db23gridpdb-signed.crt -pwd ${DBUSR_PWD}

    4. Affichez le contenu du portefeuille, assurez-vous que le certificat d'utilisateur du serveur de base de données est maintenant affiché sous Certificats d'utilisateur. Le portefeuille que vous utiliserez pour le serveur de base de données et le module d'écoute est maintenant prêt à être déployé.

      orapki wallet display -wallet ${DB_TLS_DIR}

  4. Déployez les fichiers de portefeuille.

    1. Copiez les fichiers de portefeuille du serveur de base de données.

      [oracle@db23aigrid ~]$ cp -v ${DB_TLS_DIR}/ewallet.p12 ${TLS_DIR}

[oracle@db23aigrid ~]$ cp -v ${DB_TLS_DIR}/cwallet.sso ${TLS_DIR}

[oracle@db23aigrid ~]$ cp -v ${DB_TLS_DIR}/ewallet.p12 ${ORA_TLS_DIR}

[oracle@db23aigrid ~]$ cp -v ${DB_TLS_DIR}/cwallet.sso ${ORA_TLS_DIR}

    2. Exportez le certificat.

      [oracle@db23aigrid ~]$ orapki wallet export -wallet ${ROOT_TLS_DIR} -dn $TLS_DN -cert ${ROOT_TLS_DIR}/rootCA.crt -pwd ${DBUSR_PWD}

  5. Faites confiance à l'autorité de certification racine à l'échelle du système en tant qu'utilisateur root.

    1. Exécutez la commande [root@db23ailvm etc]# cp -v /home/oracle/wallet_tls/certificates/rootCA/rootCA.crt /etc/pki/catrust/source/anchors/.

    2. Exécutez la commande [root@db23ailvm etc]# update-ca-trust extract.

    3. Définissez les autorisations de fichier appropriées.

      cd /etc/ORACLE/WALLETS/

chmod -R 755 oracle/

Tâche 1.3 : Configurer Oracle pour la communication TLS

  1. Modifiez sqlnet.ora pour le protocole TLS unidirectionnel et ajoutez les lignes suivantes.

    [oracle@db23aigrid ~]$ cd $ORACLE_HOME/network/admin

[oracle@db23aigrid ~]$ vi sqlnet.ora

    SSL_CLIENT_AUTHENTICATION = FALSE

  2. Modifiez tnsnames.ora et assurez-vous que les entrées TCP et TCPS sont ajoutées pour la base de données enfichable.

    Ajustez les valeurs en fonction de votre environnement :

    [oracle@db23aigrid ~]$ cd $ORACLE_HOME/network/admin

[oracle@db23aigrid ~]$ vi tnsnames.ora

    DB23GRIDPDB=(DESCRIPTION=(CONNECT_TIMEOUT=5)(TRANSPORT_CONNECT_TIMEOUT=3)(RETRY_COUNT=3)
(ADDRESS_LIST=(LOAD_BALANCE=on)(ADDRESS=(PROTOCOL=TCP)(HOST=db23aigrid)(PORT=1521)))
(CONNECT_DATA=(SERVICE_NAME=DB23GRIDPDB.sub10121249210.dbsecvcn.oraclevcn.com)))

DB23GRIDPDB_TLS=(DESCRIPTION=(CONNECT_TIMEOUT=5)(TRANSPORT_CONNECT_TIMEOUT=3)(RETRY_COUNT=3)
(ADDRESS_LIST=(LOAD_BALANCE=on)(ADDRESS=(PROTOCOL=TCPS)(HOST=db23aigrid)(PORT=1522)))
(CONNECT_DATA=(SERVICE_NAME=DB23GRIDPDB.sub10121249210.dbsecvcn.oraclevcn.com)))

Tâche 1.4 : Configurer le module d'écoute avec TLS

Tâche 1.5 : Valider la connectivité TLS

  1. Testez le protocole TCP (non TLS).

    $ sqlplus system/QAZxswedc123##@DB23GRIDPDB

SQL> SELECT sys_context('USERENV', 'NETWORK_PROTOCOL') as network_protocol FROM dual;

NETWORK_PROTOCOL

Tcp

  2. Tester TCPS (TLS activé)

    $ sqlplus system/QAZxswedc123##@DB23GRIDPDB_TLS

SQL> SELECT sys_context('USERENV', 'NETWORK_PROTOCOL') as network_protocol FROM dual;

NETWORK_PROTOCOL

Tcps

Tâche 1.6 : Configurer l'hôte client pour TLS

Note : Préalables pour cette tâche.

Pour configurer l'hôte client, procédez comme suit :

  1. Copiez les fichiers de certificat et de portefeuille à partir du serveur de base de données. Vous pouvez utiliser n'importe quel outil de transfert de fichiers préféré pour déplacer ces fichiers du serveur de base de données vers le client.

    cd /home/oracle/wallet_tls/certificates/

tar -cvf rootCA.tar rootCA

chmod 755 rootCA.tar

cp rootCA.tar /tmp/

  2. définition des répertoires clients;

    [opc@bastion-server8-8 ~]$ sudo su - oracle

[oracle@bastion-server8-8 ~]$ mkdir wallet_db23aigrid_tls

[oracle@bastion-server8-8 ~]$ mkdir -p network/admin

[oracle@bastion-server8-8 ~]$ export TNS_ADMIN=/home/oracle/network/admin

  3. Transférez les fichiers de certificat et de portefeuille du serveur de base de données vers l'instance client.

    [oracle@bastion-server8-8 ~]$ cp rootCA.tar wallet_db23aigrid_tls /

[oracle@bastion-server8-8 ~]$ cd wallet_db23aigrid_tls /

[oracle@linuxclient23:~/wallet_db23aigrid_tls]$ cp /tmp/rootCA.tar

  4. Extraire les fichiers de certificat.

    [oracle@linuxclient23:~/wallet_db23aigrid_tls]$ tar -xvf rootCA.tar

  5. Configurez tnsnames.ora.

    [oracle@bastion-server8-8 ~]$ cd ~/network/admin

[oracle@linuxclient23:~/instantclient_23_7/network/admin]$ vi tnsnames.ora

   DB23GRIDPDB=
   (DESCRIPTION=(CONNECT_TIMEOUT=5)(TRANSPORT_CONNECT_TIMEOUT=3)(RETRY_COUNT=3)
   (ADDRESS_LIST=(LOAD_BALANCE=on)(ADDRESS=(PROTOCOL=TCP)(HOST=143.47.117.99)(PORT=1521)))
   (CONNECT_DATA=(SERVICE_NAME=DB23GRIDPDB.sub10121249210.dbsecvcn.oraclevcn.com)))

   DB23GRIDPDB_TLS=(DESCRIPTION=(CONNECT_TIMEOUT=5)(TRANSPORT_CONNECT_TIMEOUT=3)(RETRY_COUNT=3)
   (ADDRESS_LIST=(LOAD_BALANCE=on)(ADDRESS=(PROTOCOL=TCPS)(HOST=db23aigrid.sub10121249210.dbsecvcn.oraclevcn.com)(PORT=
   1522)))
   (CONNECT_DATA=(SERVICE_NAME=DB23GRIDPDB.sub10121249210.dbsecvcn.oraclevcn.com))
   (SECURITY = (SSL_SERVER_DN_MATCH=TRUE)))

  6. Configurez sqlnet.ora.

    [oracle@linuxclient23:~/instantclient_23_7/network/admin]$ vi sqlnet.ora

   SSL_CLIENT_AUTHENTICATION = FALSE
   WALLET_LOCATION =
   (SOURCE =(METHOD = FILE)
   (METHOD_DATA =(DIRECTORY =/home/oracle/wallet_db23aigrid_tls/rootCA)))

Tâche 1.7 : Tester la connexion à partir de l'instance de client

  1. Testez le protocole TCP (non TLS).

    $ sqlplus system/QAZxswedc123##@DB23GRIDPDB

SQL> SELECT sys_context('USERENV', 'NETWORK_PROTOCOL') as network_protocol FROM dual;

  NETWORK_PROTOCOL

  Tcp

  2. Testez le protocole TCPS (TLS activé).

    $ sqlplus system/QAZxswedc123##@DB23GRIDPDB_TLS

SQL> SELECT sys_context('USERENV', 'NETWORK_PROTOCOL') as network_protocol FROM dual;

  NETWORK_PROTOCOL

  Tcps

Tâche 2 : Configurer l'intégration de Microsoft Azure et de la base de données

Tâche 2.1 : Enregistrer le serveur de base de données dans Microsoft Azure

  1. Connectez-vous au portail Microsoft Azure en tant qu'administrateur disposant des privilèges Microsoft Entra ID pour enregistrer des applications.

  2. Dans la page Centre d'administration du répertoire Azure Active, sélectionnez Microsoft Entra ID.

  3. Cliquez sur Inscriptions à l'application et sur Nouvelle inscription.

  4. Entrez les informations suivantes .

    • Nom : Entrez BaseDB-Server.

    • Qui peut utiliser cette application ou accéder à cette API? : Sélectionnez Comptes dans ce répertoire organisationnel seulement.

  5. Cliquez sur Enregistrer.

  6. Sous Application enregistrée, cliquez sur Exposer une API.

  7. Cliquez sur Ajouter à côté de URI d'ID application et Enregistrer. Conservez les autres valeurs par défaut.

  8. Cliquez sur Ajouter une portée et entrez les informations suivantes.

    • Nom de la portée : Entrez session:scope:connect.

    • Qui peut consentir? : Entrez Administrateurs et utilisateurs.

    • Nom d'affichage du consentement de l'administrateur : Sélectionnez Se connecter à la base de données.

    • Description du consentement de l'administrateur : Sélectionnez Se connecter à la base de données.

    • Nom d'affichage du consentement de l'utilisateur : Sélectionnez Se connecter à la base de données.

    • Description du consentement de l'utilisateur : Sélectionnez Se connecter à la base de données.

    • État : Sélectionnez Activé.

    Cliquez sur Ajouter une portée. Une fois ajouté, assurez-vous de copier la valeur de Portée.

    Présenter une API

  9. Sous Configuration de jeton, ajoutez Réclamation en tant que mise à jour avec Type de jeton en tant qu'accès.

    Note : Cette opération est requise dans le cadre de l'activation du jeton v2 Microsoft Entra ID. Pour plus d'informations sur les jetons v2, voir Activation des jetons d'accès v2 avec l'ID Microsoft.

    Vous devrez peut-être également modifier le manifeste de l'application dans l'ID Microsoft Entra pour obtenir un jeton v2.

    Ajouter une réclamation

  10. Sous Rôles d'application, ajoutez les rôles d'application suivants.

    Ajouter des rôles d'application

  11. Dans Aperçu, copiez l'URI de l'ID application, l'ID répertoire (locataire) et l'ID application (client).

  12. Naviguez jusqu'à Accueil, Applications d'entreprise, BaseDB-Serveur et cliquez sur Ajouter un utilisateur/groupe pour affecter des utilisateurs.

  13. Sous Utilisateurs, sélectionnez votre utilisateur. Lors de la génération du jeton d'accès, cet utilisateur affecté sera utilisé pour l'authentification unique.

  14. Sous Sélectionner un rôle, sélectionnez pdb.users, cliquez sur Sélectionner et Affecter.

  15. Répétez les étapes 13 et 14 pour le même utilisateur et affectez dba.role.

Tâche 2.2 : Enregistrer le client de base de données dans Microsoft Azure

  1. Enregistrez l'application client de base de données avec les informations suivantes.

    • Nom : Entrez BaseDB-Client.

    • Types de compte pris en charge : Sélectionnez Comptes dans ce répertoire organisationnel seulement.

    • URI de redirection : Entrez Client public/natif - <http://localhost>.

  2. Sous Gérer, cliquez sur Autorisations d'API et Ajouter une autorisation. Sélectionnez API utilisées par mon organisation, BaseDB-Server, Autorisations déléguées, Autorisation sous session:scope:connect et cliquez sur Ajouter des autorisations.

  3. Dans Aperçu, copiez l'URI de l'ID application et l'ID répertoire (locataire).

Tâche 2.3 : Configurer Database Server pour Microsoft Azure

Exécutez les interrogations suivantes pour configurer Microsoft Azure AD en tant que fournisseur d'identités et pour créer des utilisateurs et des rôles globaux de base de données.

  1. Vérifiez le fournisseur d'identités courant dans la base de données enfichable.

    SELECT NAME, VALUE FROM V$PARAMETER WHERE NAME='identity_provider_type';

  2. Définissez Microsoft Azure comme fournisseur d'identités.

    ALTER SYSTEM SET IDENTITY_PROVIDER_TYPE=AZURE_AD SCOPE=BOTH;

  3. Valider le fournisseur d'identités mis à jour.

    SELECT NAME, VALUE FROM V$PARAMETER WHERE NAME='identity_provider_type';

  4. Définir la configuration du fournisseur d'identités. Remplacez application_id_uri, tenant_id et app_id par des valeurs copiées dans la tâche 2.1.11.

    ALTER SYSTEM SET IDENTITY_PROVIDER_CONFIG =
'{
   "application_id_uri": "api://b7ae5060-667c-47b7-83f8-71283df2a2f6" ,
   "tenant_id": "ef2b4271-9238-4dcd-8c56-d3e915e37c6f",
   "app_id": "b7ae5060-667c-47b7-83f8-71283df2a2f6"
}' SCOPE=BOTH;

  5. Créer des utilisateurs et des rôles globaux dans la base de données.

    CREATE USER allusers IDENTIFIED GLOBALLY AS 'AZURE_ROLE=pdb.users';
CREATE USER hrapp IDENTIFIED GLOBALLY AS 'AZURE_ROLE=hr.app';
CREATE ROLE dba_azure IDENTIFIED GLOBALLY AS 'AZURE_ROLE=dba.role';

  6. Accordez des privilèges aux utilisateurs et aux rôles.

    GRANT CREATE SESSION TO allusers;
GRANT CREATE SESSION TO hrapp;
GRANT pdb_dba TO dba_azure;

Tâche 2.4 : Configurer l'utilitaire d'aide pour générer un jeton d'accès Microsoft Azure

Dans cette tâche, nous allons utiliser un utilitaire Python pour générer un jeton d'accès qui serait enregistré dans un fichier, puis référencé par SQL*Plus. Cet utilitaire nécessite l'exécution du module MSAL.

  1. Enregistrez l'utilitaire Python à partir d'ici : Get-Token.py.

  2. Dans le code Python suivant, remplacez la valeur de scope par la valeur copiée dans la tâche 2.1.8. De même, mettez à jour les valeurs de client_id et tenant_id avec les valeurs de la tâche 2.2.3.

  3. Exécutez le code Python à l'aide de la commande suivante.

    python ./get-token.py

  4. Si tout est configuré correctement, cela devrait déclencher une redirection du navigateur vers le portail Microsoft Azure pour l'authentification des utilisateurs. Lors de l'authentification, un fichier de jeton sera généré dans le répertoire où la commande Python a été exécutée, qui contient le jeton d'accès. Le jeton d'accès et le jeton d'actualisation seront également imprimés dans la fenêtre de terminal.

  5. (Facultatif), vous pouvez valider le jeton généré en naviguant ici : jwt.io et en collant la chaîne de jeton dans le champ Encodé. Le champ Décodé affiche des informations sur la chaîne de jeton.

Tâche 2.5 : Se connecter à l'aide de SQL*PLUS

  1. Tester la connexion au jeton Microsoft Azure à l'aide de SQL*PLUS.

    sqlplus /nolog

    conn /@(description= (retry_count=20) (retry_delay=3) (address= (protocol=tcps) (port=1522) (host=db23aigrid.sub10121249210.dbsecvcn.oraclevcn.com)) (connect_data=(service_name=DB23GRIDPDB.sub10121249210.dbsecvcn.oraclevcn.com))(security=(SSL_SERVER_DN_MATCH=TRUE)(TOKEN_AUTH=OAUTH)(TOKEN_LOCATION=/home/oracle)))

  2. Vérifiez l'utilisateur connecté.

    Note : Une fois connecté, vous pouvez exécuter les interrogations suivantes pour extraire les informations propres à la session de l'utilisateur.

    • La variable CURRENT_USER retourne l'utilisateur courant actif.
    • ALLUSERS est l'utilisateur de schéma partagé qui a été affecté au moyen des rôles d'application Microsoft Entra ID.
    • AUTHENTICATED_IDENTITY représente l'utilisateur authentifié à partir de Microsoft Entra ID.
    • ENTERPRISE_IDENTITY retourne le GUID de l'utilisateur authentifié à partir de l'ID Microsoft Entra.
    • SESSION_ROLES retourne la liste combinée des rôles accordés localement et accordés au moyen de mappages globaux au moyen des rôles d'application Microsoft Entra ID.

    1. Exécutez l'interrogation suivante pour vérifier l'utilisateur courant.

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

      Sortie :

      SYS_CONTEXT('USERENV','CURRENT_USER')


ALLUSERS

    2. Exécutez l'interrogation suivante pour vérifier l'utilisateur authentifié.

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

      Sortie :

      SYS_CONTEXT('USERENV','AUTHENTICATED_IDENTITY')


<anujtrip.ai@gmail.com>

    3. Exécutez l'interrogation suivante pour vérifier le GUID de l'utilisateur authentifié.

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

      Sortie :

      SYS_CONTEXT('USERENV','ENTERPRISE_IDENTITY')


7eb35b90-dcxxx5-bc0b-48789368e9cf

    4. Exécutez l'interrogation suivante pour vérifier les rôles d'application.

      SELECT * FROM SESSION_ROLES;

      Sortie :

      ROLE

DBA_AZURE

PDB_DBA

CONNECT

Étapes suivantes

Avec la mise en œuvre réussie de l'authentification basée sur Microsoft Entra ID, vous pouvez aligner les rôles d'utilisateur et les politiques d'accès via une gouvernance centralisée des identités. En tirant parti des mappings globaux pour les utilisateurs et les rôles de schéma partagés, vous pouvez rationaliser le contrôle d'accès et réduire la complexité administrative. En outre, il est essentiel de surveiller les sessions d'utilisateur et les modèles d'accès pour améliorer la sécurité et assurer la conformité aux politiques organisationnelles. Vous devriez également envisager d'étendre cette intégration à d'autres bases de données ou applications pour assurer une gestion uniforme des identités dans l'ensemble de l'entreprise.

Remerciements

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur le site docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal Oracle Learning YouTube. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation sur le produit, visitez Oracle Help Center.