Remarques :

Authentification d'Oracle Database 23ai avec l'ID Microsoft Entra

Introduction

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

L'authentification est gérée via un jeton d'accès OAuth2 émis par l'ID Microsoft Entra. Ce jeton, qui inclut l'identité de l'utilisateur et les détails d'accès, 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, garantissant ainsi un processus de connexion sécurisé et rationalisé.

Pourquoi avons-nous besoin de cela ?

Alors que les entreprises accordent de plus en plus la priorité à la sécurité, la gestion de l'accès aux données sensibles devient essentielle. Oracle Database, en collaboration avec Microsoft Entra ID, permet une authentification sécurisée sans mot de passe, en exploitant des systèmes de gestion des identités modernes 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, garantissant ainsi un accès cohérent et sécurisé à 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 via Microsoft Entra ID et transmettre le jeton d'accès à la base de données à l'instance Oracle Database via l'API client. Les outils de base de données existants, tels que SQL*Plus, peuvent être configurés pour utiliser un jeton d'ID Entra Microsoft 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é. Par la suite, SQL*Plus référence ce jeton lors de l'établissement de la connexion.

Flux d'authentification utilisateur Entra avec sqlplus

Remarque : ce tutoriel utilise un script Python exploitant MSAL pour acquérir des jetons de sécurité. Pour plus d'informations, reportez-vous à Présentation 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 de TLS. Reportez-vous à la documentation propre au type de base de données : sur site, Exadata, DBaaS ou Autonomous. TLS est préconfiguré pour Autonomous Database. Vous pouvez donc ignorer cette étape.

Public

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

Objectifs

Prérequis

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

Tâche 1.1 : préparation du 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. Connexion à 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 pluggable.

    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 base de données sous le chemin racine du portefeuille à l'aide du GUID de base de données pluggable.

    [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 les éléments suivants 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. Appliquer 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 d'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 les 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 sécurisé.

      orapki wallet display -wallet ${ROOT_TLS_DIR}

    6. Exportez le certificat sécurisé d'autorité de certification racine à utiliser lors de la création du 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. Affichez 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 sécurisé au portefeuille (obtenez-le auprès de l'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 la faire signer.

      [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. Une entrée apparaît sous Certificats demandés.

      orapki wallet display -wallet ${DB_TLS_DIR}

    6. Affichez 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 la 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. Affichez le certificat utilisateur du serveur signé.

      cat ${DB_TLS_DIR}/db23gridpdb-signed.crt

    3. Importez le certificat utilisateur de 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 et assurez-vous que le certificat utilisateur du serveur de base de données est désormais affiché sous Certificats utilisateur. Le portefeuille que vous utiliserez pour le serveur de base de données et le processus d'écoute est maintenant prêt à être déployé pour utilisation.

      orapki wallet display -wallet ${DB_TLS_DIR}

  4. Déployez des 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. Exporter 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 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 pour TCP et TCPS sont ajoutées pour la base de données pluggable.

    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 processus d'écoute avec TLS

Tâche 1.5 : validation de 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 le 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 : configuration de l'hôte client pour TLS

Remarque : prérequis 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. Configurez les répertoires client.

    [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 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 : Inscrire le serveur de base de données dans Microsoft Azure

  1. Connectez-vous au portail Microsoft Azure en tant qu'administrateur disposant de privilèges Microsoft Entra ID permettant d'inscrire des applications.

  2. Sur la page Centre d'administration d'annuaire Azure Active, sélectionnez ID Entra Microsoft.

  3. Cliquez sur Inscriptions d'applications et sur Nouvelle inscription.

  4. Saisissez les informations suivantes .

    • Nom : entrez BaseDB-Server.

    • Qui peut utiliser cette application ou accéder à cette API ? : sélectionnez Comptes dans cet annuaire organisationnel uniquement.

  5. Cliquez sur Inscrire.

  6. Sous Application inscrite, cliquez sur Exposer une API.

  7. Cliquez sur Ajouter en regard de URI d'ID d'application et Enregistrer. Conservez les autres valeurs par défaut.

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

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

    • Qui peut donner son consentement ? : entrez Administrateurs et utilisateurs.

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

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

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

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

    • Etat : sélectionnez Activé.

    Cliquez Ajouter une portée. Une fois ajoutée, veillez à copier la valeur de Portée.

    Exposer une API

  9. Sous Configuration de jeton, ajoutez Demande en tant que upn avec Type de jeton comme Accès.

    Remarque : ceci est requis dans le cadre de l'activation du jeton v2 ID Entra Microsoft. Pour plus d'informations sur les jetons v2, reportez-vous à Activation des jetons d'accès v2 Microsoft Entra ID.

    Vous devrez peut-être également modifier le manifeste de l'application dans Microsoft Entra ID 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 Présentation, copiez l'URI d'ID d'application, l'ID de répertoire (locataire) et l'ID d'application (client).

  12. Accédez à l'accueil, aux applications Enterprise, au BaseDB-serveur et cliquez sur Ajouter un utilisateur/groupe pour affecter des utilisateurs.

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

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

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

Tâche 2.2 : Inscrire 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 cet annuaire organisationnel uniquement.

    • URI de réacheminement : entrez Client public/natif - <http://localhost>.

  2. Sous Gérer, cliquez sur Droits d'accès d'API et sur Ajouter un droit d'accès. Sélectionnez API utilisées par mon organisation, BaseDB-Serveur, Autorisations déléguées, Autorisation en tant que session:scope:connect et cliquez sur Ajouter des autorisations.

  3. Dans Présentation, copiez l'URI d'ID d'application et l'ID de répertoire (locataire).

Tâche 2.3 : configurer le serveur de base de données pour Microsoft Azure

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

  1. Vérifiez le fournisseur d'identités en cours dans la base de données pluggable.

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

  2. Définissez Microsoft Azure en tant que fournisseur d'identités.

    ALTER SYSTEM SET IDENTITY_PROVIDER_TYPE=AZURE_AD SCOPE=BOTH;

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

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

  4. Définissez 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éez des utilisateurs globaux et un rôle 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. Octroyer 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 Helper pour générer le 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 requiert l'exécution du module MSAL.

  1. Enregistrez l'utilitaire Python à partir de cet emplacement : 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 est généré dans le répertoire dans lequel 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 accédant 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 : Connexion à l'aide de SQL*PLUS

  1. Testez la connexion par 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é.

    Remarque : une fois connecté, vous pouvez exécuter les requêtes suivantes pour extraire les informations propres à la session de l'utilisateur.

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

    1. Exécutez la requête suivante pour vérifier l'utilisateur actuel.

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

      Sortie :

      SYS_CONTEXT('USERENV','CURRENT_USER')


ALLUSERS

    2. Exécutez la requête 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 la requête 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 la requête suivante pour vérifier les rôles d'application.

      SELECT * FROM SESSION_ROLES;

      Sortie :

      ROLE

DBA_AZURE

PDB_DBA

CONNECT

Etapes suivantes

Avec l'authentification basée sur l'ID Microsoft Entra implémentée avec succès, vous pouvez aligner les rôles utilisateur et les stratégies d'accès via une gouvernance centralisée des identités. En exploitant les mappings globaux pour les rôles et les utilisateurs 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 utilisateur et les modèles d'accès pour améliorer la sécurité et assurer la conformité avec les politiques organisationnelles. Vous devriez également envisager d'étendre cette intégration à d'autres bases de données ou applications pour maintenir une gestion cohérente des identités dans l'ensemble de l'entreprise.

Remerciements

Ressources de formation supplémentaires

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

Pour obtenir la documentation produit, consultez le site Oracle Help Center.