Hinweis:

Sicherer Zugriff auf Oracle Integration mit Zugriffstoken aus Microsoft Entra ID

Einführung

Da Oracle Integration-Kunden Multicloud-Strategien einführen, müssen sie häufig Geschäftsanwendungen und -prozesse über verschiedene Cloud-Provider hinweg verbinden. Beispiel: Ein Unternehmen verfügt möglicherweise über eine Anwendung, die auf Microsoft Azure ausgeführt wird und auf Daten aus Oracle Cloud Infrastructure-Anwendungen zugreifen muss. Normalerweise erhalten Sie ein Token von Oracle Cloud Infrastructure Identity and Access Management (OCI IAM), um diese Daten abzurufen. Die Verwendung mehrerer Cloud-Provider bedeutet jedoch, mehrere Token zu verwenden, die komplex sein und Sicherheitsrisiken darstellen können.

Stellen Sie sich vor, wie praktisch es wäre, wenn Sie ein OAuth-Token zur Integration mit Anwendungen über verschiedene Cloud-Provider hinweg verwenden könnten. In diesem Tutorial wird beschrieben, wie ein OAuth-Provider eines Drittanbieters zum Aufrufen des Oracle Integration-Ablaufs verwendet wird.

Architektur

Lassen Sie uns den Lösungsfluss visualisieren:

Bild 1

Der Prozess beginnt damit, dass der Benutzer oder die Geschäftsanwendung ein OAuth-Token aus der Microsoft Entra-ID erhält. Nach der Erfassung wird dieses Token verwendet, um den über OCI API Gateway angegebenen Endpunkt aufzurufen. Das OCI-API-Gateway, das für die Verwendung eines benutzerdefinierten Autorisierers OCI Functions (früher als Oracle Functions bezeichnet) konfiguriert ist, ruft diese Autorisiererfunktion zuerst auf, um das Token zu validieren. Nach erfolgreicher Validierung ruft er dann den tatsächlichen Backend-Endpunkt auf, der Oracle Integration-Ablauf ist.

Lassen Sie uns nun die Details der Implementierung dieses Prozesses untersuchen. Der Einfachheit halber werden wir es in drei Schritte aufteilen:

Warum sollten Sie die Berechtigungstypen für Ressourceneigentümerkennwortzugangsdaten (ROPC) und JSON Web Token (JWT) verwenden, um Zugriffstoken von Microsoft Entra ID und OCI IAM abzurufen?

Die gemeinsame Verwendung von ROPC- und JWT-Assertion-Berechtigungen bietet einen optimierten und sicheren Ansatz für die Verarbeitung von Authentifizierung und Tokenaustausch in einer Multicloud-Umgebung.

Zielgruppe

Ziele

Voraussetzungen

Aufgabe 1: Anwendung mit Microsoft Entra ID registrieren

Um die IAM-Funktionen von Microsoft Entra ID nutzen zu können, einschließlich des Zugriffs auf geschützte Ressourcen (Diagramm-APIs), müssen Sie eine Anwendung registrieren.

  1. Anwendung registrieren. Weitere Informationen finden Sie unter Anwendung bei der Microsoft-Identitätsplattform registrieren.

  2. Notieren Sie sich den Wert Application (client) ID im Abschnitt Überblick.

    Bild 2

  3. Gehen Sie zu Verwalten, Zertifikate und Secrets, und fügen Sie ein Client Secret hinzu. Notieren Sie sich den Secret-Wert, der in einer späteren Aufgabe verwendet wird.

    Bild 3

Aufgabe 2: Erforderliche Schritte für JWT-Benutzer-Assertion in OCI-Identitätsdomain

  1. Führen Sie die erforderlichen Aufgaben hier aus: Voraussetzungen für JWT-Benutzer-Assertion.

  2. Nachdem die Oracle Integration-Anwendung auf die erforderlichen Geltungsbereiche validiert wurde, werden selbstsignierte Schlüsselpaare generiert und eine vertrauliche Anwendung konfiguriert. Notieren Sie sich den Wert unter Geltungsbereich, private_key.pem, Client-ID und Client Secret.

    Hinweis: Verwenden Sie beim Importieren des Private Keys als vertrauenswürdiger Partner in die vertrauliche Anwendung dieselbe alias wie beim Erstellen der selbstsignierten Schlüsselpaare, und notieren Sie sich bei späteren Aufgaben die alias.

  3. Erstellen Sie eine dynamische Gruppe, damit der Ressourcentyp function aus einem bestimmten Compartment Secrets aus dem OCI Vault-Service lesen kann.

    Bild 6

Aufgabe 3: Secrets in OCI Vault erstellen

Mit der Option Manuelle Secret-Generierung von OCI Vault können Sie die Secrets speichern, die aus Aufgabe 1 und Aufgabe 2 erfasst wurden. Weitere Informationen finden Sie unter Secret in einem Vault erstellen.

Bild 4

Nachdem die Secrets erstellt wurden, kopieren Sie den OCID-Wert aus dem Abschnitt Secret-Informationen, und speichern Sie ihn für spätere Aufgaben.

Bild 5

Aufgabe 4: Datei func.py erstellen und konfigurieren

Wir verwenden OCI Functions als benutzerdefinierten Autorisierer, um das Zugriffstoken der Microsoft Entra-ID zu validieren und das OCI-IAM-Zugriffstoken als back_end_token zu generieren.

  1. Erstellen Sie zum Starten eine Anwendung. In OCI Functions ist eine Anwendung eine logische Gruppierung von Funktionen. Die Eigenschaften, die Sie für eine Anwendung angeben, bestimmen die Ressourcenzuweisung und -konfiguration für alle Funktionen in dieser Anwendung. Weitere Informationen finden Sie in Anwendungen erstellen.

  2. Nachdem die Anwendung erstellt wurde, fügen Sie die Konfiguration der Anwendung hinzu. Wir holen die folgenden Elemente aus unserem Funktionscode ab und machen ihn tragbarer und konfigurierbarer, ohne den Code zu ändern. Geben Sie Schlüssel und Wert ein, und klicken Sie auf +.

    Fügen Sie die Client-IDs aus der Microsoft Entra-ID, OCI-Identitätsdomains, die OCID der in Aufgabe 3 erfassten Secrets, den Alias, den aus Aufgabe 2 erfassten Geltungsbereich und einen Diagrammendpunkt https://graph.microsoft.com/v1.0/me hinzu, anhand dessen das Microsoft Entra-ID-Token validiert wird.

    Bild 7

  3. Um die Funktion zu erstellen, gehen Sie zu Erste Schritte, und klicken Sie auf OCI Cloud Shell starten, um die interaktive Linux-cloud shell im Browser zu öffnen. Nachdem OCI Cloud Shell geladen wurde, können Sie die benutzerdefinierte Autorisierer-Oracle-Funktion direkt aus OCI Cloud Shell erstellen, entwickeln und bereitstellen.

  4. Um die Funktion mit der Fn-Projektbefehlszeilenschnittstelle (CLI) zu erstellen, geben Sie den folgenden Befehl für eine Python-Funktion fn init --runtime python MyCustomAuthorizer ein, und klicken Sie auf Eingabetaste.

    Bild 8

  5. Das Boilerplate der Funktion wird erstellt, jetzt kann es entsprechend bearbeitet werden, um die benutzerdefinierte Autorisiererlogik einzuschließen. Wechseln Sie zum Funktionsordner, und bearbeiten Sie die Datei func.py. Kopieren Sie das folgende Code-Snippet, und fügen Sie es ein.

    Bild 9

    import io
import json
import logging
import jwt
import datetime
from datetime import timedelta
import time
import base64

from fdk import response
import requests
from requests.auth import HTTPBasicAuth
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.backends import default_backend
import ociVault

oauth_apps = {}

def initContext(context):
    # This method takes elements from the Application Context and from OCI Vault to create the OAuth App Clients object.
    if (len(oauth_apps) < 2):
        try:
            logging.getLogger().info("initContext: Initializing context")

            oauth_apps['idcs'] = {'introspection_endpoint': context['idcs_token_endpoint'],
                                'client_id': context['idcs_app_client_id'],
                                'scope':context['idcs_oauth_scope'],
                                'alias':context['alias'],
                                'client_secret': ociVault.getSecret(context['idcs_client_secret_ocid'])}
            oauth_apps['AD'] = {'token_endpoint': context['ad_endpoint'],
                                'client_id': context['ad_app_client_id'],
                                'client_secret': ociVault.getSecret(context['ad_client_secret_ocid'])}

        except Exception as ex:
            logging.getLogger().error("initContext: Failed to get config or secrets" + str(ex))
            raise


def getAuthContext(token, client_apps):
    # This method populates the Auth Context that will be returned to the gateway.
    auth_context = {}
    access_token = token[len('Bearer '):]
    jwtToken = json.loads(json.dumps(jwt.decode(access_token, options={"verify_signature": False})))
    # Calling MSFT to validate the token
    try:
    logging.getLogger().info("getAuthContext: Calling Token Introspection function") 
    respIntrospectToken = introspectToken(access_token, client_apps['AD']['token_endpoint'], client_apps['AD']['client_id'], client_apps['AD']['client_secret'])
    except Exception as ex:
            logging.getLogger().error("getAuthContext: Failed to introspect token" + str(ex))
            raise

    # If AD confirmed the token valid and active, we can proceed to populate the auth context
    if (respIntrospectToken.status_code == 200):
        auth_context['active'] = True
        auth_context['principal'] = jwtToken['upn']
        auth_context['scope'] = 'https://graph.microsoft.com/.default'
        # Retrieving the back-end Token
        backend_token = getBackEndAuthToken(client_apps['idcs']['introspection_endpoint'], client_apps['idcs']['client_id'], client_apps['idcs']['client_secret'],client_apps['idcs']['scope'],client_apps['idcs']['alias'],auth_context['principal'])

        # The maximum TTL for this auth is the lesser of the API Client Auth (Entra ID) and the Gateway Client Auth (OCI IAM)
        if (datetime.datetime.fromtimestamp(jwtToken['exp']) < (datetime.datetime.utcnow() + timedelta(seconds=backend_token['expires_in']))):
            auth_context['expiresAt'] = (datetime.datetime.fromtimestamp(jwtToken['exp'])).replace(tzinfo=datetime.timezone.utc).astimezone().replace(microsecond=0).isoformat()
        else:
            auth_context['expiresAt'] = (datetime.datetime.utcnow() + timedelta(seconds=backend_token['expires_in'])).replace(tzinfo=datetime.timezone.utc).astimezone().replace(microsecond=0).isoformat()
        # Storing the back_end_token in the context of the auth decision so we can map it to Authorization header using the request/response transformation policy
        auth_context['context'] = {'back_end_token': ('Bearer ' + str(backend_token['access_token']))}

    else:
        # API Client token is not active, so we will go ahead and respond with the wwwAuthenticate header
        auth_context['active'] = False
        auth_context['wwwAuthenticate'] = 'Bearer realm=\"identity.oraclecloud.com\"'

    return(auth_context)

def introspectToken(access_token, introspection_endpoint, client_id, client_secret):
    # This method simply invokes the introspection api as configured in the configuration screen.  
    # The real validation happens in the getAuthContext function.  
    #payload = {'token': access_token}
    headers = {'Accept': 'application/json',
            'Authorization':'Bearer '+access_token}
    try:
        logging.getLogger().info("introspectToken: Introspecting Token") 
        resp = requests.get(introspection_endpoint,
                            headers=headers)
        print(resp)

    except Exception as ex:
        logging.getLogger().error("introspectToken: Failed to introspect token" + str(ex))
        raise

    return resp

def getBackEndAuthToken(token_endpoint, client_id, client_secret, scope, alias, principal):
    # This method gets the token from the back-end system (ORDS in this case)
    try:
        logging.getLogger().info("getBackEndAuthToken: Getting Backend Token") 
        print("Sub is " + principal)

        with open("private_key.pem", "rb") as key_file:
            private_key = serialization.load_pem_private_key(
                key_file.read(),
                password=None,
                backend=default_backend()
            )

        headers = {
            "alg": "RS256",
            "typ": "JWT",
            "kid": "abc"
        }

        claims = {
            "sub": principal,
            "aud": "https://identity.oraclecloud.com/",
            "iss": client_id,
            "iat": int(time.time()),
            "exp": int(time.time()) + 3600,  # 1 hour expiration
            "jti": "8c7df446-bfae-40be-be09-0ab55c655436"  # random number
        }

        logging.getLogger().info("Claims : ")
        logging.getLogger().info(claims) 

        jwt_assertion = jwt.encode(
            payload=claims,
            key=private_key,
            algorithm="RS256",
            headers=headers
        )
        logging.getLogger().info("Assertion is :") 
        logging.getLogger().info(jwt_assertion) 

        encoded = client_id + ":" + client_secret
        baseencoded = base64.urlsafe_b64encode(encoded.encode('UTF-8')).decode('ascii')
        payload = {'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
                'scope':scope, 'assertion':jwt_assertion}
        headers = {'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8', 'Authorization': 'Basic %s' % baseencoded, 'Accept': '*/*'}
        backend_token = json.loads(requests.post(token_endpoint,
                                                data=payload,
                                                headers=headers).text)
        logging.getLogger().info("Backend token in generated :") 
        logging.getLogger().info(backend_token) 

    except Exception as ex:
        logging.getLogger().error("getBackEndAuthToken: Failed to get ORDS token" + str(ex))
        raise

    return backend_token



def handler(ctx, data: io.BytesIO = None):
    initContext(dict(ctx.Config()))
    logging.getLogger().info(oauth_apps)

    auth_context = {}
    try:
        logging.getLogger().info("handler: Started Function Execution") 
        gateway_auth = json.loads(data.getvalue())
        auth_context = getAuthContext(gateway_auth['token'], oauth_apps)
        if (auth_context['active']):
            logging.getLogger().info('Authorizer returning 200...')
            return response.Response(
                ctx,
                response_data=json.dumps(auth_context),
                status_code = 200,
                headers={"Content-Type": "application/json"}
                )
        else:
            logging.getLogger().info('Authorizer returning 401...')
            return response.Response(
                ctx,
                response_data=json.dumps(str(auth_context)),
                status_code = 401,
                headers={"Content-Type": "application/json"}
                )

    except (Exception, ValueError) as ex:
        logging.getLogger().info('error parsing json payload: ' + str(ex))

        return response.Response(
            ctx,
            response_data=json.dumps(str(auth_context)),
            status_code = 500,
            headers={"Content-Type": "application/json"}
            )

    • Importvorgänge

      • io, json, logging, datetime, time, base64: Standard-Python-Librarys für die Verarbeitung von I/O-, JSON-Daten, Logging-, Datums- und Uhrzeitvorgängen und base64-Codierung.
      • jwt: Bibliothek zur Codierung und Decodierung von JSON Web Tokens (JWT).
      • requests: Library zum Erstellen von HTTP-Anforderungen.
      • HTTPBasicAuth: Klasse zur Verarbeitung der HTTP-Basisauthentifizierung.
      • serialization, default_backend: Aus der Kryptografiebibliothek, die zur Verarbeitung kryptografischer Vorgänge verwendet wird.
      • ociVault: Ein benutzerdefiniertes Modul für die Interaktion mit OCI Vault.

    • Globale Variable

      • oauth_apps:-Dictionary zum Speichern der Anwendungskonfiguration.

    • Functions

      • initContext(context): Zweck dieser Funktion ist es, die Anwendungskonfiguration mit den Kontextdaten und Secrets aus dem OCI Vault zu initialisieren. Er empfängt das Kontext-Dictionary-Objekt, das als erstes in der Haupt-Handler-Methode aufgerufen wird, und ruft die Secrets mit der in Aufgabe 5 erläuterten Funktion getSecret() aus OCI Vault ab.

      • getAuthContext(token, client_apps): Füllt den Authentifizierungskontext für das OCI-API-Gateway auf und gibt ihn zurück. Extrahiert und decodiert das Zugriffstoken. Ruft die Funktion introspectToken() auf, um das Token mit der Entra-ID zu validieren. Wenn das Token gültig ist, legt den Authentifizierungskontext fest, ruft die Funktion getBackEndAuthToken() auf, um das Backend-Token aus OCI IAM abzurufen, und legt die Ablaufzeit fest. Wenn das Token nicht gültig ist, wird der Header wwwAuthenticate auf einen Authentifizierungsfehler gesetzt.

      • introspectToken(access_token, introspection_endpoint, client_id, client_secret): Validiert das Token mit dem angegebenen introspection_endpoint. Erstellt eine GET-Anforderung an den Introspektionsendpunkt mit dem Token. Gibt die Antwort vom Introspektions- oder Validierungsendpunkt zurück. Da die Microsoft Entra-ID keinen API-Endpunkt für die Introspektion OAuth aufweist, rufen wir den konfigurierten Endpunkt mit dem als Eingabe empfangenen Token auf.

      • getBackEndAuthToken(token_endpoint, client_id, client_secret, scope, alias, principal): Lädt den Private Key aus einer PEM-Datei. Erstellt JWT-Ansprüche und kodiert sie in einer JWT-Assertion. Bereitet die Payload und die Header für die Tokenanforderung vor. Erstellt eine POST-Anforderung an den Tokenendpunkt, um das Backend-Token abzurufen, und gibt das Backend-Token an die Funktion getAuthContext() zurück.

      • handler(ctx, data: io.BytesIO = None): Hauptfunktion zur Verarbeitung der Funktionsausführung. Initialisiert den Kontext OAuth mit der Funktion initContext() und ruft die Funktion getAuthContext() auf, um den Authentifizierungskontext abzurufen. Gibt eine 200-Antwort zurück, wenn das Token gültig ist. Andernfalls wird eine 401-Antwort zurückgegeben. Protokolliert und gibt bei Fehlern eine 500-Antwort zurück.

Aufgabe 5: Datei ociVault.py erstellen und konfigurieren

Erstellen Sie eine ociVault.py-Datei im selben Ordner, und fügen Sie das folgende Code-Snippet ein. Diese Utilityfunktion liest die Secrets aus dem OCI Vault-Service.

# Utility Function to get secrets from OCI Vault
import logging
import oci
import base64

def getSecret(ocid):
    signer = oci.auth.signers.get_resource_principals_signer()
    try:
        client = oci.secrets.SecretsClient({}, signer=signer)
        secret_content = client.get_secret_bundle(ocid).data.secret_bundle_content.content.encode('utf-8')
        decrypted_secret_content = base64.b64decode(secret_content).decode('utf-8')
    except Exception as ex:
        logging.getLogger().error("getSecret: Failed to get Secret" + ex)
        print("Error [getSecret]: failed to retrieve", ex, flush=True)
        raise
    return decrypted_secret_content

Hinweis: Behalten Sie die Datei private_key.pem aus Aufgabe 2 im selben Ordner bei.

Bild 10

Aufgabe 5: Funktion testen

Um die Funktion zu testen, müssen wir die Funktion bereitstellen und dann aufrufen, indem wir das Microsoft Entra ID-Token als Eingabe übergeben.

  1. Navigieren Sie zum Funktionsordner, und führen Sie den folgenden Befehl fn -v deploy --app MyCustomAuthorizer aus, um ihn bereitzustellen. Der Fn-Projekt-CLI-Befehl erstellt die Funktion und stellt sie in der OCI Functions-Anwendung bereit.

    Bild 11

    Hinweis: Nehmen Sie vor dem Deployment der Funktionsanwendung fdk>=0.1.74, requests, oci, pyjwt, serialization in die Datei requirements.txt auf.

  2. Generieren Sie ein Zugriffstoken aus der Microsoft Entra-ID mit dem OAuth 2.0 ROPC-Ablauf mit dem Postman-Client.

    Bild 12

  3. Notieren Sie sich das Zugriffstoken, um eine payload.json zu generieren, die als Eingabe zum Testen der OCI Functions übergeben wird. Speichern Sie die JSON-Datei im selben Funktionsverzeichnis.

    Bild 13

  4. Nachdem Sie die Payload gespeichert haben, können Sie den folgenden Befehl ausführen, um die Ausführung der Funktion nachzuahmen, wie sie über das OCI-API-Gateway aufgerufen wird, cat payload.json | fn invoke <AppName> <function name>, wie in der folgenden Abbildung gezeigt.

    Bild 14

    Wenn das Microsoft Entra-ID-Token gültig ist, wird eine Antwort wie in der folgenden Abbildung angezeigt. Dort wird der OCI-IAM-Tokenwert im Wert back_end_token der Kontextstruktur angezeigt.

Aufgabe 6: OCI API Gateway konfigurieren

OCI API Gateway ist eine vollständig verwaltete, skalierbare, cloudnative API-Managementplattform, die eine Suite von Services bietet, von der schnellen API-Bereitstellung bis hin zum Lebenszyklusmanagement und zur Integration von Backend-Services. Wir nutzen das API-Gateway, um die Autorisierung für Oracle Integration mit einem externen Identitätsprovider wie der Microsoft Entra ID zu vermitteln.

Erstellen Sie zunächst ein neues API-Gateway, und erstellen Sie dann ein neues Deployment im API-Gateway.

  1. Navigieren Sie zu Entwicklerservices, API-Verwaltung und Gateways. Geben Sie die folgenden Informationen ein, und klicken Sie auf Gateway erstellen.

    Bild 15

    Bild 16

  2. Klicken Sie auf der Seite Gatewaydetails auf Deployment erstellen, und geben Sie die folgenden erforderlichen Informationen für Ihr API-Deployment ein.

    • Name: Geben Sie einen Namen ein.
    • Pfadpräfix: Definieren Sie den Pfad.
    • Compartment: Wählen Sie das entsprechende Compartment für Ihr API-Deployment aus.

    Bild 17

  3. Fügen Sie die Details der Authentifizierungs-Policy hinzu. Hier konfigurieren Sie die OCI Functions, die als benutzerdefinierter Autorisierer aufgerufen werden soll. Wählen Sie die in Aufgabe 4 erstellte Funktion aus.

    Bild 18

  4. Konfigurieren Sie auf der Seite Routen das API-Routing zum Backend-Service. In diesem Tutorial definieren wir das Routing zum Oracle Integration-Endpunkt.

    Bild 19

  5. Klicken Sie auf Routenanforderungs-Policys anzeigen. Hier führt der Benutzer den Swap von Authentifizierungstoken aus der OCI Functions-Antwort an den Authentifizierungsheader der Anforderung aus.

    Bild 20

    In diesem Schritt wird das Authentifizierungstoken für den Backend-Service basierend auf dem Backend-Identitätsprovider festgelegt. In unserem Szenario legen wir das Bearer-Token für OCI IAM so fest, wie es vom benutzerdefinierten Autorisierer OCI Functions empfangen wurde. Hier konfigurieren wir den Autorisierungsheader so, dass er mit dem Wert ${request.auth[back_end_token]} überschrieben wird. Beachten Sie, dass back_end_token Teil des Kontextes in der Antwortstruktur der Oracle-Funktion ist. Stellen Sie sicher, dass dieser Ausdruck erfolgreich ausgewertet wird, nachdem der benutzerdefinierte Autorisierer OCI Functions abgeschlossen ist.

  6. Nachdem Sie die Konfiguration erfolgreich geprüft haben, klicken Sie auf Änderungen speichern, um das Deployment zu speichern, und warten Sie, bis der Deployment-Status in Aktiv geändert wird.

    Bild 21

    Nachdem Sie das API-Deployment aktiviert haben, kopieren Sie den Endpunkt (Basis-URL) aus dem Abschnitt Deployment-Informationen. Diese URL dient als Endpunkt für Ihr Deployment, bei dem der Geschäftsprozess oder die Anwendung die Oracle Integration-Endpunkte mit dem Microsoft Entra ID-Bearer-Token aufruft. Die Basis-URL wird in der nächsten Aufgabe verwendet.

    Bild 22

Aufgabe 7: API testen

Rufen Sie zunächst mit dem Postman-Client ein Zugriffstoken von Microsoft Entra ID ab. Wir verwenden den ROPC-Ablauf, um sicherzustellen, dass das Zugriffstoken die erforderlichen Identitätsinformationen enthält.

  1. Kopieren Sie das Zugriffstoken, da es beim Aufrufen der API aus dem API-Gateway verwendet wird.

    Bild 12

  2. Erstellen Sie eine neue REST-Anforderung mit einer Basisendpunkt-URL, die in Aufgabe 6 aus dem API-Gateway und dem Oracle Integration-Endpunkt kopiert wurde, wie in der folgenden Abbildung dargestellt. Verwenden Sie das Bearer-Token im Anforderungsheader.

    Bild 23

  3. Klicken Sie auf Senden, um die API-Anforderung aufzurufen. Dabei wird Oracle Integration ausgeführt und eine erfolgreiche Ausgabe ausgegeben.

    Bild 24

Nächste Schritte

Die API in Oracle API Gateway wurde erfolgreich mit einem OAuth-Token aus der Microsoft Entra-ID aufgerufen und erhielt eine Antwort vom Oracle Integration-REST-Triggerablauf. Diese Integration ist entscheidend für Kunden, die digitale Services über verschiedene Cloud-Anbieter hinweg verbinden.

Danksagungen

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie im Oracle Learning YouTube-Channel auf weitere kostenlose Lerninhalte zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.