Cloud-Funktionen und externe Prozeduren aufrufen

In einer On-Premise-Oracle Database (Enterprise, Standard, Express, Personal Editions) können Sie benutzerdefinierte Funktionen in PL/SQL, Java oder C schreiben, um Funktionen bereitzustellen, die in integrierten SQL- oder SQL-Funktionen nicht verfügbar sind. Sie können diese benutzerdefinierten Funktionen in einer SQL-Anweisung überall dort aufrufen, wo ein Ausdruck auftreten kann. Siehe Benutzerdefinierte Funktionen.

Ab Oracle Database 19c können Sie Python-Skripte mit dem Feature für die eingebettete Python-Ausführung in SQL erstellen, speichern und ausführen. Siehe Eingebettete Python-Ausführung mit OML4Py.

Oracle Autonomous AI Database on Dedicated Exadata Infrastructure erweitert benutzerdefinierte Funktionen in die Cloud, indem Sie SQL-Funktionen schreiben können, die serverlose Compute-Services in der Cloud aufrufen, wie z.B. OCI Functions und AWS Lambda Functions oder externe Prozeduren, die C/C++-Routinen, Shell- oder Python-Skripte enthalten, werden in einer OCI-Compute-VM ausgeführt, die außerhalb der autonomen KI-Datenbank ausgeführt wird.

Verwandte Themen

Cloud-Funktionen und externe Prozeduren

Mit benutzerdefinierten Funktionen können Sie extern verfügbare Funktionen aus PL/SQL- oder SQL-Code in der Datenbank aufrufen. Mit benutzerdefinierten Funktionen können Sie die folgenden externen Funktionen aufrufen:

  • Oracle Cloud Infrastructure Functions: Oracle Cloud Infrastructure Functions sind vollständig verwaltet, mehrmandantenfähig, hoch skalierbar, On-Demand, Functions-as-a-Service-Plattform. Oracle Cloud Infrastructure Functions basiert auf Oracle Cloud Infrastructure der Unternehmensklasse und wird von der Open Source-Engine Fn-Projekt unterstützt. Weitere Informationen finden Sie unter Überblick über OCI Functions.
  • AWS Lambda Functions: AWS Lambda ist ein serverloser, ereignisgesteuerter Compute-Service, mit dem Sie Code für praktisch jede Anwendung oder jeden Backend-Service ausführen können, ohne Server bereitstellen oder verwalten zu müssen. Weitere Informationen finden Sie unter AWS Lambda.
  • Externe Prozeduren: Externe Prozeduren sind Funktionen, die in einer Sprache der dritten Generation (z.B. C) geschrieben sind, oder BS-Shellskripte oder Python-Skripte, die als SQL-Funktionen oder PL/SQL-Prozeduren oder -Funktionen aufgerufen werden können. Weitere Informationen finden Sie unter Was ist eine externe Prozedur.

OCI Cloud-Funktionen als SQL-Funktionen aufrufen

Zeigt die Schritte zum Aufrufen von OCI-Cloud-Funktionen als SQL-Funktionen in Ihrer Autonomous AI Database on Dedicated Exadata Infrastructure an.

Bevor Sie mit diesen Schritten fortfahren, wird davon ausgegangen, dass Sie OCI Functions in einem OCI-Mandanten und Compartment erstellt und bereitgestellt haben. Weitere Informationen finden Sie unter OCI Functions.

Nachdem Sie OCI-Funktionen verwendet haben, verwenden Sie die PL/SQL-APIs DBMS_CLOUD und DBMS_CLOUD_FUNCTION, um einen Katalog von SQL-Wrapper-Funktionen in der autonomen KI-Datenbank zu erstellen, die ihre jeweilige Cloud-Funktion über ihre API-Endpunkte referenzieren und aufrufen. Sie verwenden die API DBMS_CLOUD_FUNCTION, um die Funktionen aus Ihrer Datenbankanwendung zu verwalten.

  1. Erstellen Sie Zugangsdaten mit der Prozedur DBMS_CLOUD.CREATE_CREDENTIAL.

    Geben Sie den API-Private Key (Inhalt der Punkt-Pem-Datei, die Sie beim Erstellen des API-Schlüssels heruntergeladen haben) des OCI-Mandantenbenutzers als Zugangsdatenobjekt, Fingerprint des Schlüssels, Mandanten-OCID und Benutzer-OCID an. Siehe Erforderliche Schlüssel und OCIDs. 

    SET DEFINE OFF
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL (
       credential_name => 'OCI_CRED', -- provide a string as the name
       user_ocid       => 'user_ocid', -- provide the OCID string for the user, obtained from OCI Console User Profile
       tenancy_ocid    => 'tenancy_ocid', -- provide the OCID string for the tenancy, obtained from OCI Console User Profile
       private_key     => 'private_key', -- provide the content of the dot-pem file that you downloaded when you created the API Key
       fingerprint     => 'fingerprint' -- provide the fingerprint string for the API key
  );
END;
/

    Dadurch wird das Zugangsdatenobjekt OCI_CRED erstellt.

    Weitere Informationen finden Sie unter Prozedur CREATE_CREDENTIAL.

  2. Erstellen Sie ein Katalogobjekt mit der Prozedur DBMS_CLOUD_FUNCTION.CREATE_CATALOG.

    Ein Katalog ist eine Sammlung von Wrapper-Funktionen, die ihre jeweiligen Cloud-Funktionen über ihre API-Endpunkte referenzieren und aufrufen. Geben Sie das Zugangsdatenobjekt, den Namen des Cloud-Serviceproviders - in diesem Fall OCI und die OCI-Regions-ID (in diesem Beispiel PHX) sowie die OCI-Compartment-ID an, in der sich die OCI Functions befinden.

    BEGIN
DBMS_CLOUD_FUNCTION.CREATE_CATALOG (
    credential_name  => 'OCI_CRED',
    catalog_name     => 'OCI_DEMO_CATALOG',
    service_provider => 'OCI',
    cloud_params     => '{"region_id":"phx", "compartment_id":"compartment_id"}'
);
END;
/

    Dadurch wird das Katalogobjekt OCI_DEMO_CATALOG erstellt.

    Weitere Informationen finden Sie unter Prozedur CREATE_CATALOG. Sie können DBA_CLOUD_FUNCTION_CATALOG View und USER_CLOUD_FUNCTION_CATALOG View abfragen, um die Liste aller Cloud-Funktionskataloge in Ihrer Datenbank abzurufen.

  3. Mit der Prozedur DBMS_CLOUD_FUNCTION.LIST_FUNCTIONS können Sie alle Cloudfunktionen im Katalog auflisten.

    SET PAGESIZE 1000

VAR function_list CLOB;

BEGIN
    DBMS_CLOUD_FUNCTION.LIST_FUNCTIONS (
      credential_name  => 'OCI_CRED', 
      catalog_name     => 'OCI_DEMO_CATALOG',
      function_list    => :function_list
 );
END;
/

PL/SQL procedure successfully completed.

SELECT JSON_QUERY (:function_list, '$' RETURNING VARCHAR2(32676) pretty) AS search_results FROM dual;

SEARCH_RESULTS
------------------------------------------------------------------------------------------------
[
  {
    "functionName"   : "create_par",
    "functionId"     : "ocid.funfc.oc1.phx.aaaa_example", 
    "invokeEndpoint" : "https://dw.us.func.oci.oraclecloud_example.com"
  },
  {
    "functionName"   : "fintech",
    "functionId"     : "ocid.funfc.oc1.phx.bbbb_example"
    "invokeEndpoint" : "https://dw.us.func.oci.oraclecloud.com_example"
  },
  {
    "functionName"   : "jwt_codec",
    "functionId"     : "ocid.funfc.oc1.phx.jwt_code_example", 
    "invokeEndpoint" : "https://dw.us.func.oci.oraclecloud_example.com"
  },
  {
    "functionName"   : "oci-objectstorage-create-par-python",
    "functionId"     : "ocid.funfc.oc1.phx.aaaaaaaas_example", 
    "invokeEndpoint" : "https://dw.us.func.oci.oraclecloud_example.com"
  },
  {
    "functionName"   : "run_dbt",
    "functionId"     : "ocid.funfc.oc1.phx.aaaaaaaav_example",
    "invokeEndpoint" : "https://dw.us.func.oci.oraclecloud_example.com"
  }
]

    Weitere Informationen finden Sie unter Prozedur LIST_FUNCTIONS.

  4. SQL Wrapper-Funktion erstellen Mit einer der beiden folgenden Methoden können Sie die Wrapper-SQL-Funktionen aus dem Katalog erstellen, die ihre jeweiligen Cloud-Funktionen aufrufen:

    • Sie können DBMS_CLOUD_FUNCTION verwenden. SYNC_FUNCTIONS Prozedur zum Generieren von SQL-Wrappern aus dem Katalogobjekt.
    • Mit DBMS_CLOUD_FUNCTION können Sie einzelne Wrapper-Funktionen manuell erstellen. Prozedur CREATE_FUNCTION.
    1. SYNC_FUNCTIONS: SYNC_FUNCTIONS synchronisiert automatisch (erstellt und/oder aktualisiert) Wrapper-Funktionen im Katalog mit der vollständigen Liste der Cloud-Funktionen, die in der Region, dem Compartment und dem Mandanten definiert sind, mit dem der Katalog erstellt wurde.
      BEGIN
 DBMS_CLOUD_FUNCTION.SYNC_FUNCTIONS (
        catalog_name => 'OCI_DEMO_CATALOG'
 );
END;
/

      Dadurch wird ein PL/SQL-Wrapper erstellt, um dem Katalog neue Funktionen hinzuzufügen und Wrapper für Funktionen zu entfernen, die aus dem Katalog gelöscht wurden.

      Sie können die Synchronisierungsergebnisse mit der folgenden Abfrage für einen bestimmten aktuellen Benutzer prüfen.

      SHOW user
TEST_USER

SELECT object_name FROM sys.all_objects WHERE owner='TEST_USER' AND object_type='FUNCTION';

OBJECT_NAME
--------------------------------------------------------------------------------
CREATE_PAR
FINTECH
JWT_CODEC
OCI-OBJECTSTORAGE-CREATE-PAR-PYTHON
RUN_DBT

      Weitere Informationen finden Sie unter Prozedur SYNC_FUNCTIONS.

    2. CREATE_FUNCTION: Sie können manuell eine SQL-Funktion in Ihrem Katalog erstellen, die ihre jeweilige Cloud-Funktion mit DBMS_CLOUD.CREATE_FUNCTION aufruft. 

      VAR function_args CLOB;

EXEC :function_args := TO_CLOB('{"command": "VARCHAR2", "value": "VARCHAR2"}');

BEGIN
    DBMS_CLOUD_FUNCTION.CREATE_FUNCTION (
        credential_name  => 'OCI_CRED',
        catalog_name     => 'OCI_DEMO_CATALOG',
        function_name    => 'FINTECH_FUNCTION',
        function_id      => 'ocid1.fnfunc.oc1.phx.aaabbbcccc_example',
        input_args       => :function_args
 );
END;
/

      Dadurch wird die Funktion FINTECH_FUN im Katalog OCI_DEMO_CATALOG als Referenz auf die jeweilige Cloud-Funktion erstellt, deren Endpunkt vom Parameter FUNCTION_ID referenziert wird. Wenn Sie die Funktion im Katalog zusammen mit den zugehörigen Argumenten aufrufen, wird die entsprechende Cloud-Funktion in OCI ausgeführt. Außerdem wird die von der Cloud-Funktion zurückgegebene Ausgabe bereitgestellt.

      Hinweis:

      Der Name der OCI-Funktion kann etwas ganz anderes sein als FINTECH_FUNCTION. Bei der Erstellung dieser Referenz wird nur die OCID der OCI-Funktion berücksichtigt, die Sie als Eingabe für den Parameter function_id angeben.

    3. CREATE_FUNCTION mit benutzerdefinierten Rückgabetypen und Antwort-Handlern: Mit der manuellen Erstellung von Funktionen können Sie benutzerdefinierte Rückgabetypen und Antwort-Handler erstellen. Dies wird im folgenden Beispiel gezeigt.

      Erstellen Sie zunächst einen Rückgabetyp und den Response Handler der Funktion.

      CREATE OR REPLACE TYPE fintech_rt AS OBJECT (
    status VARCHAR2(1000),  
    output CLOB
);
/
Type created.

CREATE OR REPLACE FUNCTION fintech_response_handler(function_response IN CLOB) 
RETURN fintech_rt
IS
      l_comp     fintech_rt;
      l_json_obj JSON_OBJECT_T;
      status     VARCHAR2(1000);
      output     CLOB;
BEGIN
      l_json_obj := JSON_OBJECT_T.parse(function_response); 
      status     := l_json_obj.get('STATUS').to_string;
      output     := l_json_obj.get('RESPONSE_BODY').to_string;
      l_comp     := fintech_rt(status,output);
      RETURN l_comp;
END;
/
Function created.

      Verwenden Sie als Nächstes diesen Typ und Response Handler bei der manuellen Erstellung der SQL Wrapper-Funktion.

      VAR input_param CLOB;
VAR l_return_type VARCHAR2(100);
VAR l_response_handler VARCHAR2(1000);

-- Define function parameters
exec :input_param       := TO_CLOB('{"command": "VARCHAR2", "value": "VARCHAR2"}');

PL/SQL procedure successfully completed.

exec :l_return_type     := 'fintech_rt';

PL/SQL procedure successfully completed.

exec :l_response_handler := 'fintech_response_handler';

PL/SQL procedure successfully completed.

BEGIN
    DBMS_CLOUD_FUNCTION.CREATE_FUNCTION (
        credential_name  => 'OCI_CRED',
        catalog_name     => 'OCI_DEMO_CATALOG',
        function_name    => 'FINTECH_FUNCTION',
        function_id      => 'ocid1.fnfunc.oc1.phx.aaabbbcccc_example',
        input_args       => :input_param,
        return_type      => :l_return_type,
        response_handler => :l_response_handler
 );
END;
/

      Sie können die Ansichten DBA_CLOUD_FUNCTION View und USER_CLOUD_FUNCTION View abfragen, um die Liste aller Funktionen in Ihrer Datenbank abzurufen.

      Weitere Informationen finden Sie unter Prozedur CREATE_FUNCTION.

      Sobald die Funktion erstellt wurde, können Sie die Funktion BESCHREIBEN, um ihre Rückgabedetails abzurufen.

      DESC fintech_fun
COLUMN STATUS format a30
COLUMN OUTPUT format a30

      Anschließend können Sie die Funktion aufrufen und die Werte für Eingabeparameter angeben.

      SET SERVEROUTPUT ON

DECLARE
    l_comp fintech_rt;
BEGIN
    l_comp := fintech_fun(command=>'tokenize',value => 'PHI_INFORMATION');

    DBMS_OUTPUT.put_line ('Status of the function   =  '|| l_comp.status);
    DBMS_OUTPUT.put_line ('Response of the function =  '|| l_comp.output);
END;
/

      Dadurch wird die Cloudfunktion fintech_fun aufgerufen, indem die Funktionsreferenz oocid1.funfn.oci.phx.aaaaaa_example im Katalog OCI_DEMO_CATALOG aufgerufen wird.

  5. Sie können eine vorhandene Funktion mit der Prozedur DROP_FUNCTION löschen.

    BEGIN
    DBMS_CLOUD_FUNCTION.DROP_FUNCTION (
        catalog_name  => 'OCI_DEMO_CATALOG',
        function_name => 'fintech_fun');
END;
/

    Dadurch wird die Funktion FINTECH_FUN aus dem Katalog OCI_DEMO_CATALOG gelöscht.

    Weitere Informationen finden Sie unter Prozedur DROP_FUNCTION.

  6. Sie können einen vorhandenen Katalog mit der Prozedur DROP_CATALOG löschen.

    BEGIN
    DBMS_CLOUD_FUNCTION.DROP_CATALOG (
        catalog_name => 'OCI_DEMO_CATALOG'
  );
END;
/

    Dadurch wird OCI_DEMO_CATALOG aus der Datenbank gelöscht.

    Weitere Informationen finden Sie unter Prozedur DROP_CATALOG.

AWS Lambda-Funktionen als SQL-Funktionen aufrufen

Zeigt die Schritte zum Aufrufen von AWS-Remotefunktionen als SQL-Funktionen in Ihrer autonomen KI-Datenbank auf dedizierter Exadata-Infrastruktur an.

Bevor Sie mit diesen Schritten fortfahren, wird davon ausgegangen, dass Sie AWS Lambda Functions in einem AWS-Mandanten erstellt und bereitgestellt haben. Weitere Informationen finden Sie unter AWS Lambda.

Um auf AWS-Lambda-Funktionen zuzugreifen, müssen Sie die erforderlichen Policys in Oracle Cloud Infrastructure konfigurieren. Weitere Informationen finden Sie unter IAM-Policy für den Zugriff auf AWS Lambda-Ressourcen erstellen und Ressourcenbasierte Policys für Lambda verwenden.

Nachdem Sie AWS Lambda-Funktionen ausgeführt haben, verwenden Sie die PL/SQL-APIs DBMS_CLOUD und DBMS_CLOUD_FUNCTION, um einen Katalog von SQL-Wrapper-Funktionen in der autonomen KI-Datenbank zu erstellen, die ihre jeweilige Cloud-Funktion über ihre API-Endpunkte referenzieren und aufrufen. Sie verwenden die API DBMS_CLOUD_FUNCTION, um die Funktionen aus Ihrer Datenbankanwendung zu verwalten.

  1. Erstellen Sie Zugangsdaten mit der Prozedur DBMS_CLOUD.CREATE_CREDENTIAL, und verwenden Sie den AWS-Secret Key als Zugangsdatenobjekt.
    SET DEFINE OFF

BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL (
    credential_name => 'AWS_CRED',
    username        => 'access_key_ID', -- ID of Secret Key
    password        => 'secret_access_key' -- Secret Key password
  );
END;
/

    Dadurch wird das Zugangsdatenobjekt AWS_CRED erstellt.

    Weitere Informationen finden Sie unter Prozedur CREATE_CREDENTIAL.

  2. Erstellen Sie ein Katalogobjekt mit der Prozedur DBMS_CLOUD_FUNCTION.CREATE_CATALOG.

    Ein Katalog ist eine Sammlung von Wrapper-Funktionen, die ihre jeweiligen Cloud-Funktionen über ihre API-Endpunkte referenzieren und aufrufen. Geben Sie das Zugangsdatenobjekt, den Namen des Cloud-Serviceproviders - in diesem Fall AWS und die AWS-Regions-ID (in diesem Beispiel ap-northeast-1) an, in der sich die AWS Lambda-Funktionen befinden. 

    BEGIN
    DBMS_CLOUD_FUNCTION.CREATE_CATALOG (
        credential_name  => 'AWS_CRED', 
        catalog_name     => 'AWS_DEMO_CATALOG', 
        service_provider => 'AWS',
        cloud_params     => '{"region_id":"ap-northeast-1"}'
 );
END;
/

    Dadurch wird das Katalogobjekt AWS_DEMO_CATALOG erstellt.

    Weitere Informationen finden Sie unter Prozedur CREATE_CATALOG. Sie können DBA_CLOUD_FUNCTION_CATALOG View und USER_CLOUD_FUNCTION_CATALOG View abfragen, um die Liste aller Kataloge in Ihrer Datenbank abzurufen.

    Die restlichen Schritte/Vorgänge - nämlich LIST_FUNCTIONS-Prozedur, SYNC_FUNCTIONS-Prozedur, CREATE_FUNCTION-Prozedur, DROP_FUNCTION-Prozedur und DROP_CATALOG-Prozedur - haben dieselbe Verwendung wie für OCI-Cloud-Funktionen beschrieben. Siehe OCI Cloud-Funktionen als SQL-Funktionen aufrufen.

Externe Untersuchungen - Übersicht

Bietet einen Überblick über externe Prozeduren und deren Verwendung in Autonomous AI Database on Dedicated Infrastructure-Anwendungen.

Externe Prozeduren sind Funktionen, die in einer Sprache der dritten Generation geschrieben und als SQL-Funktionen oder PL/SQL-Prozeduren oder -Funktionen aufgerufen werden. SQL und PL/SQL eignen sich am besten für eine schnelle und effiziente Daten- und Transaktionsverarbeitung in der Datenbank. Externe Prozeduren können SQL und PL/SQL ergänzen, indem sie rechen- und speicherintensive Aufgaben in einer dedizierten, externen VM ausführen und die Ergebnisse an die Datenbank zurückgeben. Typische Beispiele für solche Aufgaben sind wissenschaftliche und technische Probleme, deren Rechenbibliotheken im Linux-Betriebssystem vorhanden sind (und nicht einfach auf eine Datenplattform übertragen werden können), Offline-Datenanalyse, Steuerung von Echtzeitgeräten und -prozessen usw.

Sie können externe Prozeduren in Ihrer autonomen KI-Datenbank mit benutzerdefinierten Funktionen aufrufen und verwenden. Anstatt diese Prozeduren in der Datenbank auszuführen, platzieren Sie den ausführbaren Code in einer dedizierten, benutzerdefinierten OCI Linux-VM, die mit einem Container und einer Laufzeit für die Ausführung von C-Programmen, Shellskripten und Python-Skripten bereitgestellt wird, sowie in Oracle SQL*Net-Librarys, um die Remote-SQL-Ausführung aus der Datenbank zu ermöglichen.

Hinweis:

Der Remotehost für externe Prozeduren muss eine OCI Linux EXTPROC-VM sein, die vom OCI Marketplace bereitgestellt und in einem geeigneten virtuellen OCI-Cloud-Netzwerk (VCN) konfiguriert ist. Weitere Informationen finden Sie unter Systemkonfiguration in OCI für externe Prozeduren und Skripte.

Die Remoteausführung auf der OCI Linux EXTPROC-VM wird nur von Autonomous AI Database on Dedicated Exadata Infrastructure auf Oracle Public Cloud ab Version 19.30 und in Oracle Database 26ai ab Version 23.26.1 unterstützt. Dieses Feature wird von der Autonomous AI Database on Dedicated Exadata Infrastructure-Datenbank auf Exadata Cloud@Customer (ExaCC) noch nicht unterstützt.

Systemkonfiguration für externe Prozeduren und Skripte

Zeigt die Schritte zum Provisioning der EXTPROC-VM und die Schritte zum Konfigurieren von OCI-Netzwerk und -Compute für die Ausführung externer Prozeduren an.

Die Architektur besteht aus den folgenden Ressourcen:

  • OCI Virtual Cloud Network wird in einem OCI-Compartment im OCI-Mandanten bereitgestellt.
  • Eine autonome KI-Datenbank, die als Instanz unter einer autonomen Containerdatenbank (ACD) erstellt wird und aus einem autonomen Exadata-VM-Cluster (AVMC) bereitgestellt wird, das auf der Exadata-Infrastruktur in Oracle Public Cloud erstellt wird.
  • Eine EXTPROC-VM, die als Teil eines EXTPROC-Stacks aus dem OCI Marketplace bereitgestellt wird.

Als Best Practice wird empfohlen, dass das AVM-Cluster in einem privaten Subnetz in einem VCN platziert wird. Die Standardroutentabelle und die Sicherheitslisten des VCN werden gemäß den Autonomous AI Database-Anforderungen im OCI-Mandanten konfiguriert. Das VCN kann über eine Standardroutentabelle und eine Standardsicherheitsliste verfügen, in der Sie alle Routing- und Sicherheitsregeln definieren können. Optional kann das VCN mit einem NAT-Gateway konfiguriert werden, wenn Autonomous AI Database-Anwendungen und andere Ressourcen im privaten Subnetz Egress-Zugriff auf das Internet benötigen.

Befolgen Sie diese minimalen OCI Networking-Konfigurationsschritte, wenn Sie die ExtProc-VM in diese Topologie einführen.

  • Sie müssen sich bei der VM ExtProc anmelden können, um die Shared Library (dot-so) mit den externen Prozeduren zu erstellen, die in C/C++ implementiert sind, die VM und den Container zu prüfen und zu konfigurieren und andere derartige Vorgänge auszuführen.
  • In der Regel wird die EXTPROC-VM so konfiguriert, dass sie sich in einem öffentlichen Subnetz im VCN befindet. In diesem Fall müssen Sie ein Internetgateway im VCN erstellen (falls nicht bereits vom Administrator konfiguriert).

    Hinweis:

    Die EXTPROC-VM darf sich NICHT in einem Subnetz befinden, dessen CIDR-Bereich 10.x.x.x beträgt. Wenn die IP-Adresse der EXPROC-VM 10.x.x.x lautet, kann sie nicht mit der autonomen KI-Datenbank kommunizieren.

  • Sie müssen eine Ingress-Regel in der Sicherheitsliste des VCN definieren, um SSH-Anmeldezugriff auf die VM über Port 22 zu ermöglichen. Sie müssen auch eine Egress-Regel in der Sicherheitsliste des VCN definieren, damit ADBD auf den Zielport 16000 zugreifen kann, der spezifisch oder allgemein für alle Zielports ist. Siehe OCI Networking-Zugriff und -Sicherheit.
  • Im Rahmen der Bereitstellung des EXTPROC-VM-Stacks geben Sie alle Client-IP-Adressen des AVMC an. Sie erhalten diese IPv4-Client-IP-Adressen aus dem OCI-Dashboard für das AVM-Cluster.
  • Anschließend erstellt das Provisioning-Tool automatisch eine Netzwerksicherheitsgruppe (NSG) mit dem Namen nsg_acl. Diese NSG enthält eine Ingress-Regel, mit der die IP-Adressen des dedizierten Autonomous Database-Clients als einzige Quellen auf das Port 16000-Ziel zugreifen können.

Erweiterte Themen

  • Wenn sich die Subnetze, in denen die VM ExtProc und die autonome KI-Datenbank gehostet werden, in demselben VCN befinden, müssen Sie keine speziellen Routingregeln in der Routingtabelle des VCN angeben. Wenn sich die Subnetze, in denen die VM ExtProc und ADBD gehostet werden, in unterschiedlichen VCNs befinden, müssen Sie VCN-Peering implementieren. Siehe VCN-Peering.
  • Wenn Sie die VM ExtProc so konfigurieren, dass sie sich in einem privaten Subnetz befindet, müssen Sie sich über einen Bastion-/Jump-off-Server bei der VM anmelden und Ingress nur in der VM ExtProc aktivieren sowie den sicheren Zugriff auf die anderen Ressourcen im privaten Subnetz, wie die Autonomous AI Database, sichern können. Weitere Informationen finden Sie in den OCI Networking-Handbüchern.

Benutzerdefinierte Funktionen mit externen Prozeduren implementieren

  1. EXTPROC-VM über OCI bereitstellen und konfigurieren MarketPlace

    1. Melden Sie sich bei der OCI-Konsole unter http://cloud.oracle.com an. Weitere Informationen finden Sie unter Bei der Oracle Cloud Infrastructure-Konsole anmelden.
    2. Klicken Sie im linken Navigationsmenü von Oracle Cloud Infrastructure auf Marketplace, und klicken Sie unter "Marketplace" auf Alle Anwendungen.
    3. Geben Sie "EXTPROC" in die Suchleiste ein, und klicken Sie auf "Suchen". Sie werden zwei Widgets sehen - eines mit der Bezeichnung "Stack" und ein anderes mit der Bezeichnung "Image".
    4. Wählen Sie das Widget Stack aus (dies ist wichtig). Dadurch gelangen Sie zur Seite Oracle Autonomous Database EXTPROC Agent-Details, auf der Sie die Stackversion, das Releasedatum und die Versionshinweise zum Stack angeben. Klicken Sie auf dieser Seite auf die Schaltfläche Stack starten. Dadurch gelangen Sie zur nächsten Seite "Stack starten".

    5. Auf der Seite "Stack starten":

      • Wählen Sie in der Dropdown-Liste Version die Packageversion des Stacks aus.
      • Wählen Sie in der Dropdown-Liste Compartment den Namen des Compartments aus, in dem Sie die EXTPROC-VM bereitstellen möchten. Sofern Sie keine besonderen Gründe dafür haben, wählen Sie dasselbe Compartment wie das des ADBD aus. (Als Best Practice sollten Sie das Root Compartment für jede Ressource vermeiden.) Prüfen Sie die Systemkonfiguration für externe Prozeduren und Skripte, um die richtige Auswahl für das Compartment zu treffen.
      • Akzeptiert die Bedingungen, und klickt auf Stack starten.

      Dadurch gelangen Sie zur nächsten Seite - zum Assistenten "Stack erstellen".

    6. Geben Sie auf dieser Seite Name, Beschreibung, CompartmentName, die Terraform-Version und alle Tag-Informationen an. Der Compartment-Name ist obligatorisch, und am wichtigsten ist die Eingabe in den Assistenten auf dieser Seite. Klicken Sie anschließend auf Weiter.
    7. Dadurch gelangen Sie zur Seite "Konfigurationsvariablen" für die EXTPROC-VM (auch EXTPROC-Agent genannt). Im ersten Teil dieser Seite werden die Informationen zu den EXTPROC-Bibliotheken und ein Wallet-Kennwort erfasst.
      • Geben Sie unter Externe Librarys eine Liste der Librarys an, die durch Komma (,) getrennt sind und von der autonomen KI-Datenbank auf dedizierter Infrastruktur aufgerufen werden können. Diese Shared Librarys enthalten die in C/C++ geschriebenen externen Prozeduren, die idealerweise in der VM selbst kompiliert und erstellt werden (entsprechend der Architektur und Umgebung).

        Hinweis:

        Da Sie die EXTPROC-VM noch erstellen, notieren Sie sich die Namen der Shared Librarys, die Sie hier angeben. Wenn die VM verfügbar ist und Sie Ihre externen Prozeduren in C/C++ entwickeln, müssen Sie daran denken, die Library/Librarys mit den oben angegebenen Namen zu kompilieren und zu erstellen.
      • Geben Sie unter Wallet-Kennwort ein Kennwort für die Wallet-Datei an, die in der VM ExtProc erstellt wird. Das Wallet und ein selbstsigniertes Zertifikat werden für die gegenseitige TLS-Authentifizierung zwischen der autonomen KI-Datenbank auf dedizierter Infrastruktur und der EXTPROC-Agent-VM generiert.
    8. Der zweite Teil der Seite mit den Konfigurationsvariablen umfasst die Netzwerkkonfiguration für die EXTPROC-VM.
      • Wählen Sie unter Compartment im Pulldown-Menü den Compartment-Namen für das VCN aus. Im obigen Beispiel wird es als adbd dargestellt. Idealerweise werden die autonome KI-Datenbank und die EXTPROC-VM in demselben VCN untergebracht, auch wenn sie sich in verschiedenen (privaten und öffentlichen) Subnetzen befinden.
      • Wählen Sie unter Netzwerkstrategie die Option Vorhandenes VCN und Subnetz verwenden aus. Wie in einem vorherigen Abschnitt angegeben, können Sie in dieser Phase Ihrer ExtProc-Entwicklungsbemühungen die Systemarchitektur mit einem VCN, AVMC und einer autonomen KI-Datenbank verwenden.

        Hinweis:

        Die andere Möglichkeit besteht darin, ein neues VCN und Subnetz mit einer eigenen Konfigurationsstrategie für den EXTPROC-VM-Agent zu erstellen. Wie unter Systemkonfiguration für externe Prozeduren und Skripte angegeben, müssen Sie die VCNs als Peer verwenden, wenn Sie die EXTPROC-VM in einem anderen VCN als die autonome KI-Datenbank platzieren möchten.
      • Überspringen Sie den nächsten Eintrag für EXTPROC Agent-Zugriffstyp. Dieses Feld ist nicht anwendbar für Autonomous AI Database on Dedicated Exadata Infrastructure.
    9. Geben Sie als Nächstes im Feld mit der Bezeichnung "Private Endpoint IP Addresses" ALLE Client-IP-Adressen des AVMC ein, auf dem die Datenbank konfiguriert ist. Sie können diese Client-IP-Adressen aus dem OCI-Konsolen-Dashboard für AVMC abrufen.
    10. Geben Sie als Nächstes die Details zum VCN und zum Subnetz an.

      Hinweis:

      Die EXTPROC-VM darf sich NICHT in einem Subnetz befinden, dessen CIDR-Bereich 10.x.x.x beträgt. Wenn die IP-Adresse der EXPROC-VM 10.x.x.x lautet, kann sie nicht mit der autonomen KI-Datenbank kommunizieren.
    11. Der letzte Teil der Konfigurationsseite umfasst die Compute-Konfiguration für den EXTPROC-VM-Agent.
      • Wählen Sie unter Compartment den Compartment-Namen im Pulldown-Menü aus. Es wird empfohlen, dass Sie die VM in demselben Compartment wie die autonome KI-Datenbank auf dedizierter Infrastruktur, das VCN und das Subnetz unterteilen, um die Fehlerbehebung zu minimieren.
      • Geben Sie unter Ausprägung, Anzahl OCPUs und Speichergröße (GBs) Werte basierend auf den Workload-Eigenschaften Ihrer externen Prozeduren ein.
      • Generieren Sie unter SSH-Schlüssel hinzufügen die SSH-Public- und -Private-Key-Dateien in Ihrem Linux-Betriebssystem, MacOS oder Windows-System. Öffnen Sie ein Terminalfenster, und führen Sie einen der folgenden Befehle aus (ED25519 ist der moderne, sicherere Algorithmus; ältere Systeme unterstützen den RSA-Verschlüsselungsalgorithmus):
        ssh-keygen -t ed25519 -C "your_email@example.com" (OR)
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

        Dadurch werden eine Private-Key-Datei ssh-key-<date-time-id>.key und eine Public-Key-Datei ssh-key-<date-time-id>.key.pub generiert. Kopieren Sie den Inhalt des SSH-Public Keys in das Fenster, oder ziehen Sie die .pub-Datei in das Fenster.

      • Klicken Sie auf Weiter.

    12. Dadurch gelangen Sie zur Seite {\b Review}. Prüfen Sie alle Eingaben, aktivieren Sie das Kontrollkästchen Anwenden ausführen, und klicken Sie auf Erstellen.

      Dadurch wird OCI Resource Manager gestartet, um den EXTPROC-VM-Stack zu erstellen. Sobald der ORM-Job erfolgreich abgeschlossen wurde, wird die EXTPROC-VM erstellt und ausgeführt.

  2. EXTPROC-VM-Systeminformationen für DBMS_CLOUD_FUNCTION-API-Eingabe erfassen

    Sie müssen EXTPROC-VM-Systeminformationen als Eingaben für die DBMS_CLOUD_FUNCTION-APIs in der autonomen KI-Datenbank angeben, um den Aufruf externer Prozeduren aus der Datenbank zu ermöglichen.

    1. Wählen Sie im linken Navigationsmenü von Oracle Cloud Infrastructure die Dropdown-Liste "Compute" aus, wählen Sie das Compartment aus, das Sie für das EXTPROC-VM-Provisioning angegeben haben, und prüfen Sie das Dashboard, in dem alle VMs im Compartment aufgeführt werden. Der ORM-Job hat die EXTPROC-VM mit dem kanonischen Namen EXTPROC-agent oder EXTPROC-agent-<setofnumbers> erstellt. Dies ist der Hostname der EXTPROC-VM-Instanz. Wenn Sie auf diesen Eintrag klicken, gelangen Sie zu der Seite, auf der die Systemdetails angezeigt werden: die öffentlichen und privaten Adressen IPV4 (IPv4 und IPv6), das Subnetz und die Imagedetails.
    2. Melden Sie sich bei der VM ExtProc mit dem SSH-Schlüssel an, den Sie bei der Erstellung des ExtProc-Stacks angegeben haben, und der IP-Adresse. Der Standardbenutzer auf der VM ist "opc. sudo", um Benutzer "oracle" zu werden.
      ➜  ~ ssh -i ssh-key-<date-time-id>.key opc@<Public-IP-Address>
Wed Nov 19 10:46:25 GMT 2025: EXTPROC Agent intialization completed.

Activate the web console with: systemctl enable --now cockpit.socket

Last login: Thu Nov 20 20:10:54 2025 from <client-IP-address>

[opc@extproc-agent-170798 ~]$ whoami
opc

[opc@extproc-agent-170798 ~]$ sudo su - oracle
Last login: Wed Nov 19 19:07:24 GMT 2025 on pts/0

      Die EXTPROC-VM enthält einen aktiven Podman-Container mit einem Oracle SQL*Net-Listener. Innerhalb des Containers ist eine Oracle-Clientumgebung mit den erforderlichen Konfigurationsdateien wie sqlnet.ora, listener.ora sowie eine Wallet-Datei für die sichere Kommunikation mit der autonomen KI-Datenbank verfügbar.

    3. Erfassen Sie die erforderlichen Systeminformationen für die PL/SQL-APIs - auf BS-Ebene und als Nächstes aus dem Podman-Container, der in der VM konfiguriert ist. Der Container führt den Oracle Listener aus, um Remoteausführungsanforderungen von der SQL- und PL/SQL-Anwendung in Autonomous AI Database zu empfangen. Er ist die Laufzeitausführungs-Engine für die externe Prozedur.
      • Vom Linux-Betriebssystem aus der FQDN (vollständig qualifizierter Domainname) des EXTPROC-VM-Hosts.
      • Vom Podman-Container aus den Listener-Status den Port auf der EXTPROC-VM, auf dem sich die Datenbank bei der VM anmeldet.
      • Im Podman-Container aus der sqlnet.ora-Spezifikation den Speicherort der Wallet-Datei.
      • Bei einer Prüfung der Wallet-Datei mit dem orapki-Tool wird der Parameterwert "Distinguished Name (DN)" für das Wallet-Zertifikat verwendet.
      [oracle@extproc-agent-170798 ~]$ hostname -f
extproc-agent-170798.subnet-name.vcn-name.oraclevcn.com

[oracle@extproc-agent-170798 ~]$ podman ps
CONTAINER ID  IMAGE                              COMMAND     CREATED       STATUS                 PORTS       NAMES
86d81c4df6ff  ghcr.io/oracle/adb-extproc:latest              23 hours ago  Up 23 hours (healthy)              adb-extproc

[oracle@extproc-agent-170798 ~]$ podman exec -it 86d81c4df6ff bash

(base) [oracle@extproc-agent-170798 admin]$ lsnrctl status

LSNRCTL for Linux: Version 23.26.0.0.0 - for Oracle Cloud and Engineered Systems on 20-NOV-2025 09:25:54

Copyright (c) 1991, 2025, Oracle.  All rights reserved.

Connecting to (DESCRIPTION=(ADDRESS=(PROTOCOL=IPC)(KEY=EXTPROC1)))
STATUS of the LISTENER
------------------------
Alias                     LISTENER
Version                   TNSLSNR for Linux: Version 23.26.0.0.0 - for Oracle Cloud and Engineered Systems
Start Date                19-NOV-2025 17:19:58
Uptime                    0 days 16 hr. 5 min. 55 sec
Trace Level               off
Security                  ON: Local OS Authentication
SNMP                      OFF
Listener Parameter File   /u01/app/oracle/product/23.0.0.0/client_1/network/admin/listener.ora
Listener Log File         /u01/app/oracle/diag/tnslsnr/extproc-agent-170798/listener/alert/log.xml
Listening Endpoints Summary...
  (DESCRIPTION=(ADDRESS=(PROTOCOL=ipc)(KEY=EXTPROC1)))
  (DESCRIPTION=(ADDRESS=(PROTOCOL=tcps)(HOST=0.0.0.0)(PORT=16000)))
Services Summary...
Service "extproccontainer.com" has 1 instance(s).
  Instance "extproccontainer", status UNKNOWN, has 1 handler(s) for this service...
The command completed successfully

(base) [oracle@extproc-agent-170798 /]$ cd $ORACLE_HOME/network/admin

(base) [oracle@extproc-agent-170798 admin]$ cat sqlnet.ora

NAMES.DIRECTORY_PATH= (TNSNAMES, EZCONNECT)
WALLET_LOCATION =(SOURCE = (METHOD = FILE)(METHOD_DATA = (DIRECTORY = /u01/app/oracle/wallets/extproc_wallet)))
tcp.invited_nodes=(20.63.19.141,20.63.19.141,20.63.19.143,20.63.19.144)
tcp.validnode_checking=yes

(base) [oracle@extproc-agent-170798 admin]$ orapki wallet display -wallet /u01/app/oracle/wallets/extproc_wallet/cwallet.sso
Oracle PKI Tool Release 23.0.0.0.0 - Production
Version 23.0.0.0.0
Copyright (c) 2004, 2025, Oracle and/or its affiliates. All rights reserved.

Requested Certificates:
User Certificates:
Subject:        CN=extproc-agent-170798
Trusted Certificates:
Subject:        CN=extproc-agent-170798
(base) [oracle@extproc-agent-170798 admin]$ exit
exit
      Im obigen Beispiel haben wir die folgenden Eingaben für die DBMS_CLOUD_FUNCTION.CREATE_CATALOG-API erfasst.
      • Die von FQDN + Portnummer gebildete Zeichenfolge ist die Eingabe für den Parameter library_listener_url. In diesem Beispiel ist es "extproc-agent-170798.subnet-name.vcn-name.oraclevcn.com:16000".
      • sqlnet.ora enthält den Speicherort der Wallet-Datei in der VM: /u01/app/oracle/wallets/extproc_wallet/cwallet.sso. Notieren Sie sich die IP-Adressliste für tcp.invited_nodes. Er muss die Liste der Client-IP-Adressen enthalten, die Sie beim Erstellen des EXTPROC-VM-Stacks als Eingabe für die Netzwerkkonfiguration angegeben haben.
      • Der Distinguished Name (DN) des Zertifikats ist die Eingabe für den Parameter library_ssl_server_cert_dn: "CN=extproc-agent-170798".
  3. Erstellen Sie die C-Bibliothek, und legen Sie sie im EXTPROC-VM-Dateisystem am angegebenen Speicherort ab

    Codieren Sie die C-Funktionen, erstellen Sie sie, und platzieren Sie die Library im angegebenen Verzeichnis im Dateisystem der Agent-VM ExtProc.

    Der Name der Bibliothek muss genau mit den Namen übereinstimmen, die Sie bei der Erstellung des ExtProc-Stacks angegeben haben. Falls Sie die Datei falsch platziert haben, finden Sie sie im Eintrag EXTPROC_DLLS des Containers initextproccontainer.ora ExtProc, wie unten gezeigt, oder im Abschnitt "Variablen" des ORM-(Oracle Resource Manager-)Jobs, der den ExtProc-Stack erstellt hat. Sie müssen die Librarys in das Verzeichnis /u01/app/oracle/extproc_libs auf der EXTPROC-Agent-VM kopieren.
    • Der vollständige Dateipfadname (in diesem Beispiel "/u01/app/oracle/extproc_libs/helloCextproc.so") ist die Eingabe für den Parameter library_remote_path von DBMS_CLOUD_FUNCTION.CREATE_CATALOG(). 
    (base) [oracle@extproc-agent-170798 client_1]$ cat $ORACLE_HOME/hs/admin/initextproccontainer.ora
SET TRACE_LEVEL=ON
SET _EXTPROC_REMOTE=TRUE
SET WHOAMI=FROMDOCKER
SET LD_LIBRARY_PATH=/u01/app/oracle/product/23.0.0.0/client_1/lib:/u01/app/oracle/extproc_libs:/opt/conda/lib
SET EXTPROC_DLLS=ONLY:/u01/app/oracle/product/extprocutils.so:/u01/app/oracle/product/23.0.0.0/client_1/lib/libgsfextproc.so:/u01/app/oracle/extproc_libs/helloCextproc.so
SET PYTHONHOME=/opt/conda
SET SCRIPTS_FOLDER_LOC_ENV=/u01/app/oracle/extproc_scripts
SET TRACE_FILE_LOC_ENV=/u01/app/oracle/extproc_logs
SET PYTHONPATH=/tmp:/u01/app/oracle/extproc_scripts
(base) [oracle@extproc-agent-170798 client_1]$ exit

[oracle@extproc-agent-170798 ~]$ cat > helloCextproc.c
#include <stdio.h>
const char* helloCextproc() {
        return ("\nHello C Extproc from FQDN: extproc-agent-170798.subnet-name.vcn-name.oraclevcn.com\n");
}
^D

[oracle@extproc-agent-170798 ~]$ gcc -shared -fPIC -o /u01/app/oracle/extproc_libs/helloCextproc.so helloCextproc.c

[oracle@extproc-agent-170798 ~]$ ls -al /u01/app/oracle/extproc_libs/
total 8
drwxr-xr-x. 2 oracle oinstall   30 Nov 19 11:14 .
drwxr-xr-x. 6 root   root       91 Nov 14 02:19 ..
-rwxr-xr-x. 1 oracle oinstall 8184 Nov 19 11:14 helloCextproc.so
[oracle@extproc-agent-170798 ~]$

    Dadurch werden alle Parametereingaben abgeschlossen, die zum Erstellen des Katalog-/Bibliotheksobjekts in der Datenbankanwendung erforderlich sind.

  4. Wallet-Datei aus der VM ExtProc in OCI Object Storage hochladen

    Im Rahmen der Erstellung der EXTPROC-Agent-Anwendung wird ein selbstsigniertes Wallet erstellt. Mit diesem Wallet können Sie auf die Agent-Instanz Extproc zugreifen.

    Um Remoteprozeduren in der EXTPROC-Agentinstanz auszuführen, verbinden sich die autonome KI-Datenbank und der EXTPROC-Agent mit Mutual Transport Layer Security (mTLS). Mit Mutual Transport Layer Security (mTLS) stellen Clients Verbindungen über eine TCPS-(Secure TCP-)Datenbankverbindung mit dem Standard TLS 1.2 und einem vertrauenswürdigen Client-Certificate-Authority(CA-)Zertifikat her.

    Hinweis:

    Sie können auch ein öffentliches Zertifikat erwerben und verwenden, das von einer Certificate Authority (CA) ausgestellt wurde.

    Als Voraussetzung müssen Sie das Wallet aus dem Verzeichnis /u01/app/oracle/extproc_wallet auf der VM exportieren, auf der EXTPROC ausgeführt wird, in OCI Object Storage.

    Hinweis:

    • Sichern Sie die Wallet-Datei. Die Wallet-Datei sowie die Datenbankbenutzer-ID und das Kennwort ermöglichen den Zugriff auf die EXTPROC-Agentinstanz. Speichern Sie Wallet-Dateien an einem sicheren Ort und teilen Sie sie nur mit autorisierten Benutzern.
    • Benennen Sie die Wallet-Datei nicht um. Die Wallet-Datei in Object Storage muss den Namen cwallet.sso haben.
  5. Katalog erstellen, SQL-Funktionen definieren und externe Prozeduren als SQL-Funktionen aufrufen

    Aus den vorherigen Schritten haben wir alle Eingaben, die wir für die DBMS_CLOUD_FUNCTION-APIs benötigen, um Remoteprozeduren aus SQL- oder PL/SQL-Datenbankanwendungen auszuführen.

    Importieren Sie als Nächstes das Wallet cwallet.sso mit den Zertifikaten für die EXTPROC-Agentinstanz aus Object Storage in eine DIRECTORY in Ihrer autonomen KI-Datenbank.

    Erstellen Sie Zugangsdaten für den Zugriff auf Object Storage, in dem Sie die Wallet-Datei cwallet.sso gespeichert haben. Informationen zu den Benutzernamen- und Kennwortparametern für verschiedene Objektspeicherservices finden Sie unter Prozedur CREATE_CREDENTIAL.

    Erstellen Sie ein DIRECTORY-Objekt in der Datenbank, und laden Sie das Wallet mit der DBMS_CLOUD.GET_OBJECT-API in das Verzeichnis herunter.

    SQL> SET DEFINE OFF

SQL> BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL (
	credential_name => 'OCI_CREDENTIAL',
	user_ocid       => '<oci_user_ocid>',
	tenancy_ocid    => '<oci_tenancy_ocid>',
	private_key     => '<API-key-dot-pem-file-contents>',
	fingerprint     => '<fingerprint-created-with-API-key>');
END;
/

SQL> CREATE DIRECTORY extprocwalletdir AS 'extprocwalletdir';

Directory created.

SQL> SELECT directory_name, directory_path FROM dba_directories WHERE directory_name LIKE '%EXTPROC%';

DIRECTORY_NAME    DIRECTORY_PATH
----------------  -------------------------------------------------------------------------
EXTPROCWALLETDIR  /u02/data/dbfs/<adbd-name>/42E945D608E16DF9E0630301000AF88D/extprocwalletdir

SQL> BEGIN
  DBMS_CLOUD.GET_OBJECT (
  credential_name     => 'OCI_CREDENTIAL',
  object_uri          => 'https://objectstorage.us-ashburn-1.oraclecloud.com/p/aN.../n/zr.../b/bucket-name-20260129/o/cwallet.sso',
  directory_name      => 'EXTPROCWALLETDIR'
  );
END;
/

    Erstellen Sie als Nächstes das Library-Objekt in der Datenbank, das die C-Bibliothek in der ExtProc darstellt, mit den Eingabeparametern, die Sie im vorherigen Schritt erfasst haben.

    SQL> BEGIN
  DBMS_CLOUD_FUNCTION.CREATE_CATALOG (
     library_name               => 'EXTPROC_LIBRARY',
     library_listener_url       => 'extproc-agent-170798.subnet-name.vcn-name.oraclevcn.com:16000',
     library_wallet_dir_name    => 'EXTPROCWALLETDIR',
     library_ssl_server_cert_dn => 'CN=extproc-agent-170798',
     library_remote_path        => '/u01/app/oracle/extproc_libs/helloCextproc.so'
  );
END;
/
PL/SQL procedure successfully completed.

SQL> SELECT catalog_name from DBA_CLOUD_FUNCTION_CATALOG WHERE catalog_name LIKE '%EXTPROC%';

CATALOG_NAME
---------------
EXTPROC_LIBRARY

    Erstellen Sie die SQL-Funktion, die der Funktion ExtProc C zugeordnet ist. Siehe den Namen der C-Funktion aus dem oben geschriebenen Programm.

    SQL> CREATE OR REPLACE FUNCTION HELLOCEXTPROC RETURN VARCHAR2 AS
    LANGUAGE C
    LIBRARY EXTPROC_LIBRARY
    NAME "helloCextproc";
/

Function created.

SQL>

    SQL-Funktion aufrufen Es ist ein erfolgreicher Lauf (siehe den Körper der C-Funktion aus der C-Routine oben).

    SQL> SELECT HELLOCEXTPROC() FROM dual;

HELLOCEXTPROC()
----------------------------------------------------------------------------------
Hello C Extproc from FQDN: extproc-agent-170798.subnet-name.vcn-name.oraclevcn.com