Functions: Funktion mit API Gateway aufrufen

• Ein kostenpflichtiger Oracle Cloud Infrastructure-Account. Siehe Für Oracle Cloud Infrastructure registrieren.
• Ihr OCI-Account wurde so konfiguriert, dass er Oracle Functions-Entwicklung unterstützt. Siehe Kurzanleitung "Oracle Functions on Cloud Shell".
• Abschluss eines der beiden Tutorials zur Einführung in Oracle Functions.
  • Functions: Erste Schritte mit Cloud Shell
  • Functions: Erste Schritte mit der Befehlszeilenschnittstelle
• Der Abschluss eines der beiden Tutorials hat folgende Auswirkungen:
  • Oracle Functions wird so eingerichtet und konfiguriert, dass Anwendungen erstellt und Funktionen bereitgestellt werden können.
  • Oracle Registry wird so eingerichtet, dass Funktionsimages gespeichert werden können.
  • Docker wird bei Oracle Registry angemeldet.
  • Das erforderliche VCN und die erforderlichen Ressourcen für Oracle Functions werden erstellt.
  • Ein API-Schlüsselpaar und ein Authentifizierungstoken werden erstellt.

Oracle-CLI

• Python 3.6+ und pip3.
• Docker Engine: Ein Linux-Rechner oder eine Linux-VM. Informationen zu Versionen und unterstützten Distributionen finden Sie unter Docker-Engine-Anforderungen.
• Docker Desktop: Verfügbar für MacOS oder Windows 10.
  • Windows 10: Windows 10 Update 2004 mit WSL 2 und Ubuntu oder andere installierte Distribution.
    • Siehe Windows-Subsystem für Linux - Installationsdokumentation für Windows 10.
    • Docker Desktop für Windows 10 installieren.
    Hinweis
    
    Docker umfasst speziellen Linux-Support für WSL 2 unter Windows 10 Update 2004.
  • MacOS: Siehe Docker Desktop für MacOS installieren.

Oracle Cloud Shell

• Wenn Sie Cloud Shell verwenden, ist die vorstehende Liste an Software bereits installiert.

Informationen zum Erstellen eines Compartments finden Sie unter Compartment erstellen. Nachdem das Compartment erstellt wurde, speichern Sie die OCID und den Namen des Compartments.

So rufen Sie die Compartment-OCID aus einem vorhandenen Compartment ab:

1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Identität und Sicherheit. Klicken Sie unter Identität auf Compartments.
2. Wählen Sie das Compartment aus.
3. Klicken Sie neben dem Feld "OCID" auf den Link Kopieren.

Speichern Sie die OCID und den Namen des Compartments.

Stellen Sie sicher, dass Sie die folgenden Informationen für das Tutorial notiert haben.

• Compartment-Name: <your-compartment-name>

  Beispiel: my-compartment

• Compartment-ID: <your-compartment-OCID>

  Beispiel: ocid1.compartment.oc1.aaaaaaa...

• VCN-Name: <your-vcn-name>

  Beispiel: my-vcn

  Öffnen Sie das Navigationsmenü, und klicken Sie auf Networking, Virtuelle Cloud-Netzwerke. Wählen Sie Ihr VCN in der Netzwerkliste aus.

• Name des öffentlichen VCN-Subnetzes: <Public-Subnet-your-vcn-name>

  Beispiel: Public-Subnet-my-vcn

  Öffnen Sie das Navigationsmenü, und klicken Sie auf Networking, Virtuelle Cloud-Netzwerke. Wählen Sie Ihr VCN in der Netzwerkliste aus.

So erstellen Sie die Anwendung:

1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter Funktionen auf Anwendungen.
2. Wählen Sie Ihr Compartment in der Dropdown-Liste Compartment aus.
3. Klicken Sie auf Anwendung erstellen.
4. Geben Sie die Formulardaten ein.
   • Name: <your-app-name>
   • VCN: <your-vcn-name>
   • Subnetze: <Public-Subnet-your-vcn-name>
5. Klicken Sie auf Erstellen.

Ihre Anwendung wird erstellt.

1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Networking, Virtuelle Cloud-Netzwerke.
2. Klicken Sie auf den Namen des VCN, das Sie für Ihre Oracle Functions-Anwendung verwendet haben.
3. Wenn das neue VCN angezeigt wird, klicken Sie auf den öffentlichen Subnetzlink.

   Die Informationen zum öffentlichen Subnetz werden unten auf der Seite mit den Sicherheitslisten angezeigt.

4. Klicken Sie auf den Link Standardsicherheitsliste oder auf den Link für die entsprechende Sicherheitsliste.

   Die Standard-Ingressregeln für das VCN werden angezeigt.

5. Klicken Sie auf Ingress-Regeln hinzufügen.

   Das Dialogfeld Ingress-Regeln hinzufügen wird angezeigt.

6. Geben Sie die folgenden Informationen für die Ingress-Regel ein. Klicken Sie nach der Eingabe aller Daten auf Ingress-Regeln hinzufügen.

   Geben Sie die Ingress-Regel wie folgt ein:

   • zustandslos: Aktiviert
   • Quelltyp: CIDR
   • Quell-CIDR: 0.0.0.0/0
   • IP-Protokoll: TCP
   • Quellportbereich: (leer lassen)
   • Zielportbereich: 443
   • Beschreibung: VCN für Anwendungen

   Wenn Sie auf Ingress-Regel hinzufügen klicken, sind HTTPS-Verbindungen zu Ihrem öffentlichen Subnetz zulässig.

Richten Sie als Nächstes eine Policy ein, mit der API Gateway Funktionen aufrufen kann.

Erstellen Sie zunächst eine dynamische Gruppe für API Gateway.

1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Identität und Sicherheit. Klicken Sie unter Identity auf Dynamic Groups.
2. Klicken Sie auf Dynamische Gruppe erstellen.
3. Geben Sie die folgenden Informationen ein, um Ihre dynamische Gruppe zu definieren.
   • Name: <name-for-your-dynamic-group>
   • Verwenden Sie unter Vergleichregeln Regel 1: <the-rule-text>

   Im Folgenden finden Sie einen Beispielnamen und die Regel, die ausgefüllt werden muss. Ersetzen Sie <your-compartment-OCID> durch den entsprechenden Wert.

   • Name: api-gtw-func-dynamic-group
   • Verwenden Sie unter Vergleichsregeln Regel 1: ALL {resource.type = 'ApiGateway', resource.compartment.id = '<your-compartment-OCID>'}
4. Klicken Sie auf Erstellen.

Erstellen Sie jetzt die Policy für API Gateway.

1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Identität und Sicherheit. Klicken Sie unter Identität auf Policys.
2. Klicken Sie auf Policy erstellen.
3. Geben Sie die folgenden Informationen ein, um die Policy zu definieren.
   • Name: <name-for-your-policy>
   • Beschreibung: <description-for policy>
   • Compartment: <name-of-functions-compartment>

   Für den Abschnitt "Policy Builder":

   • Klicken Sie auf Manuellen Editor anzeigen.
   • Geben Sie Ihre Policy in das Textfeld ein. Beispiel:

     Allow dynamic-group api-gtw-func-dynamic-group to use functions-family in compartment <your-compartment-name>

     Hinweis
     
     Der letzte Parameter ist der Compartment-Name, nicht die Compartment-OCID.
4. Klicken Sie auf Erstellen.

Sie haben eine Policy erstellt, um API Gateway die Verwendung von Funktionen zu erlauben.

1. Öffnen Sie ein Terminal.
2. Erstellen Sie ein Verzeichnis zum Speichern Ihrer Funktionen, und wechseln Sie in dieses Verzeichnis.

   mkdir my-dir-name
   cd my-dir-name                        
                        

3. Erstellen Sie eine "Hello World-Python-Funktion mit Fn.

   fn init --runtime python my-func-name

   Mit diesem Befehl wird ein Verzeichnis namens my-func-name erstellt. Es enthält die Funktion und die Konfigurationsdateien.

4. Wechseln Sie in das Verzeichnis.
5. Stellen Sie die Funktion bereit.

   fn -v deploy --app your-app-name

   Wenn die Docker-Images erstellt, per Push an OCIR übertragen und schließlich in Oracle Functions bereitgestellt werden, werden verschiedene Meldungen angezeigt.

6. Rufen Sie die Funktion auf.

   fn invoke your-app-name my-func-name

   Es wird Folgendes zurückgegeben: {"message": "Hello World"}

7. Rufen Sie die Funktion mit einem Parameter auf.

   echo -n '{"name":"Bob"}' | fn invoke your-app-name my-func-name

   Es wird Folgendes zurückgegeben: {"message": "Hello Bob"}

So erstellen Sie ein API-Gateway:

1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter API-Verwaltung auf Gateways.
2. Wählen Sie Ihr Compartment in der Dropdown-Liste Compartment aus.
3. Klicken Sie auf Gateway erstellen
4. Geben Sie die folgenden Informationen ein, um Ihr API-Gateway zu definieren.
   • Name: <your-gateway-name>
   • Typ: <Public>
   • Compartment: <your-compartment-name>
   • Virtuelles Cloud-Netzwerk in <your-vcn-name>: <select-your-vcn>
   • Subnetz in <your-compartment-name: <your-public-subnet-name>
5. Klicken Sie auf Erstellen. Die Erstellung des API-Gateways kann einige Minuten dauern.

Erstellen Sie als Nächstes ein Deployment für Ihr API-Gateway.

1. Klicken Sie auf der linken Seite des Bildschirms im Abschnitt "Ressourcen" auf Deployments.
2. Klicken Sie auf Deployment erstellen.
3. Stellen Sie sicher, dass als Deployment-Typ Völlig neu ausgewählt ist.
4. Füllen Sie zur Definition des Deployments den Abschnitt Basisinformationen aus.
   • Name: <your-deployment-name>
   • Path-Präfix (Beispiel): /v1
   • Compartment: <your-compartment-name>
   • API-Anforderungs-Policys: Standardwerte übernehmen
   • API-Logging-Policys: Standardwert Informationen übernehmen
5. Klicken Sie auf Weiter. Das Dialogfeld Routen wird angezeigt, wobei Route 1 ausgewählt ist.
6. Füllen Sie zur Definition der Route den Abschnitt Route 1 aus.
   • Pfad: <your-route-path>

     Beispiel: /http-info

   • Methoden: GET POST
   • Typ: Oracle Functions
   • Anwendung in <your-compartment-name>: Wählen Sie die von Ihnen erstellte Functions-Anwendung aus.
   • Funktionsname: Wählen Sie die Funktion aus, die Sie im Konfigurationsabschnitt erstellt haben.
7. Klicken Sie auf Weiter. Das Dialogfeld "Prüfen" wird angezeigt. Es enthält eine Zusammenfassung der von Ihnen ausgewählten Optionen.
8. Klicken Sie auf Erstellen. Ihr Deployment wird erstellt.
9. Klicken Sie neben Ihrem Gateway auf den Link "Deployments". Kopieren Sie den Basisendpunkt für das von Ihnen erstellte Deployment.

   Beispiel: https://aaaaa.apigateway.us-ashburn-X.oci.customer-oic.com/v1

Nachdem Ihr API-Gateway und Ihr Deployment erstellt wurden, können Sie die Installation testen. Erstellen Sie ein einfaches Skript für den Befehl curl. Um die URL für curl zu erstellen, fügen Sie den Deployment-Pfad zum Endpunkt hinzu.

1. Erstellen Sie die Skriptdatei: touch gtw01.sh && chmod 755 gtw01.sh
2. Fügen Sie den Befehl "curl" zur Skriptdatei hinzu:

   #!/bin/bash
   curl <your-api-gateway-endpoint>/http-info

3. Der Befehl gibt Folgendes zurück: {"message":"Hello World"}

Sie haben Ihr API-Gateway mit einer Python-Boilerplate-Funktion verbunden. Als Nächstes aktualisieren Sie Ihre Python-Funktion, um Informationen anzuzeigen, die in einer HTTP-Anforderung übergeben werden.

Wenn Sie sich die Boilerplate-Funktion ansehen, sieht Ihre Python-Funktion etwa wie folgt aus.

import io
import json
import logging

from fdk import response


def handler(ctx, data: io.BytesIO = None):
    name = "World"
    try:
        body = json.loads(data.getvalue())
        name = body.get("name")
    except (Exception, ValueError) as ex:
        logging.getLogger().info('error parsing json payload: ' + str(ex))
    
    logging.getLogger().info("Inside Python Hello World function")
    return response.Response(
       ctx, response_data=json.dumps(
           {"message": "Hello {0}".format(name)}),
       headers={"Content-Type": "application/json"}
    )

Mit diesem Code als Ausgangspunkt konvertieren die folgenden Abschnitte die Funktion in eine Python-Funktion, die HTTP- und Konfigurationsdaten zurückgibt.

Aktualisieren Sie zunächst die Funktion für die erforderlichen Packages.

1. Aktualisieren Sie die Datei requirements.txt für das Package oci.

   fdk
   oci                    
                   

2. Aktualisieren Sie für die erforderlichen Packages die import-Anweisungen in func.py für die HTTP-Features:

   import io
   import json
   import oci
   import logging
   from urllib.parse import urlparse, parse_qs                    
                   

   Das Package oci ist für einige Kontextanforderungen erforderlich. Die Packages urlparse, parse_qs werden für das Parsing verwendet.

Entfernen Sie zunächst den Hauptteil der Funktion. Die response-Methode und der zugehörige Code werden nach und nach wieder hinzugefügt.

import io
import json
import oci
import logging
from urllib.parse import urlparse, parse_qs  
                
from fdk import response

def handler(ctx, data: io.BytesIO = None):                
            

Fügen Sie als Nächstes Code hinzu, um HTTP-Informationen in der Antwort anzuzeigen. Hier sehen Sie den Code sowie nachfolgende Kommentare.

import io
import json
import oci
import logging
from urllib.parse import urlparse, parse_qs  
                
from fdk import response

def handler(ctx, data: io.BytesIO = None):
    logging.getLogger().info("HTTP function start")
    
    resp = {}
    
    # retrieving the request headers
    headers = ctx.Headers()
    logging.getLogger().info("Headers: " + json.dumps(headers))
    resp["Headers"] = headers
    
    # retrieving the request body, e.g. {"key1":"value"}
    try:
        requestbody_str = data.getvalue().decode('UTF-8')
        if requestbody_str:
            resp["Request body"] = json.loads(requestbody_str)
        else:
            resp["Request body"] = {}
    except Exception as ex:
        print('ERROR: The request body is not JSON', ex, flush=True)
        raise
    
    # retrieving the request URL, e.g. "/v1/http-info"
    requesturl = ctx.RequestURL()
    logging.getLogger().info("Request URL: " + json.dumps(requesturl))
    resp["Request URL"] = requesturl
    
    # retrieving query string from the request URL, e.g. {"param1":["value"]}
    parsed_url = urlparse(requesturl)
    resp["Query String"] = parse_qs(parsed_url.query)
    logging.getLogger().info("Query string: " + json.dumps(resp["Query String"]))
    
    # retrieving the request method, e.g. "POST", "GET"...
    method = ctx.Method()
    if method:
        logging.getLogger().info("Request Method: " + method)
    resp["Request Method"] = method
    else:
        logging.getLogger().info("No Request Method")
        resp["Request Method"] = None

• Die handler-Funktion empfängt Systeminformationen zur aktuellen Anforderung über die Parameter ctx und data.
• Alle Daten werden dem resp-Dictionary hinzugefügt, das schließlich in der Antwort zurückgegeben wird.
• Beachten Sie, dass der Laufzeitkontext der Funktion (ctx) einen Großteil der HTTP-Daten enthält, die von einer Anforderung übergeben werden, einschließlich: Header, Anforderungs-URL und Methode.
• Der Parameter data gibt den Text der Anforderung zurück.

Rufen Sie als Nächstes Oracle Functions-bezogene Daten aus dem Kontext ab, und geben Sie dann eine Antwort zurück. Kommentare folgen.

    # retrieving the function configuration
    resp["Configuration"] = dict(ctx.Config())
    logging.getLogger().info("Configuration: " + json.dumps(resp["Configuration"]))
    
    # retrieving the Application ID, e.g. "ocid1.fnapp.oc1.phx.aaaaxxxx"
    appid = ctx.AppID()
    logging.getLogger().info("AppID: " + appid)
    resp["AppID"] = appid
    
    # retrieving the Function ID, e.g. "ocid1.fnfunc.oc1.phx.aaaaxxxxx"
    fnid = ctx.FnID()
    logging.getLogger().info("FnID: " + fnid)
    resp["FnID"] = fnid
    
    # retrieving the Function call ID, e.g. "01E9FE6JBW1BT0C68ZJ003KR1Q"
    callid = ctx.CallID()
    logging.getLogger().info("CallID: " + callid)
    resp["CallID"] = callid
    
    # retrieving the Function format, e.g. "http-stream"
    fnformat = ctx.Format()
    logging.getLogger().info("Format: " + fnformat)
    resp["Format"] = fnformat
    
    # retrieving the Function deadline, e.g. "2020-05-29T05:24:46Z"
    deadline = ctx.Deadline()
    logging.getLogger().info("Deadline: " + deadline)
    resp["Deadline"] = deadline
    
    logging.getLogger().info("function handler end")
    return response.Response(
        ctx, 
        response_data=json.dumps(resp),
        headers={"Content-Type": "application/json"}
    )

Beachten Sie, dass alle Functions-bezogenen Daten aus dem Objekt ctx abgerufen werden, einschließlich AppID, FnID und Format.

Hier sehen Sie den Code der endgültigen Funktion.

import io
import json
import oci
import logging
from urllib.parse import urlparse, parse_qs

from fdk import response

def handler(ctx, data: io.BytesIO = None):
    logging.getLogger().info("HTTP function start")
    
    resp = {}
    
    # retrieving the request headers
    headers = ctx.Headers()
    logging.getLogger().info("Headers: " + json.dumps(headers))
    resp["Headers"] = headers
    
    # retrieving the request body, e.g. {"key1":"value"}
    try:
        requestbody_str = data.getvalue().decode('UTF-8')
        if requestbody_str:
            resp["Request body"] = json.loads(requestbody_str)
        else:
            resp["Request body"] = {}
    except Exception as ex:
        print('ERROR: The request body is not JSON', ex, flush=True)
        raise
    
    # retrieving the request URL, e.g. "/v1/http-info"
    requesturl = ctx.RequestURL()
    logging.getLogger().info("Request URL: " + json.dumps(requesturl))
    resp["Request URL"] = requesturl
    
    # retrieving query string from the request URL, e.g. {"param1":["value"]}
    parsed_url = urlparse(requesturl)
    resp["Query String"] = parse_qs(parsed_url.query)
    logging.getLogger().info("Query string: " + json.dumps(resp["Query String"]))
    
    # retrieving the request method, e.g. "POST", "GET"...
    method = ctx.Method()
    if method:
        logging.getLogger().info("Request Method: " + method)
        resp["Request Method"] = method
    else:
        logging.getLogger().info("No Request Method")
        resp["Request Method"] = None
    
    # retrieving the function configuration
    resp["Configuration"] = dict(ctx.Config())
    logging.getLogger().info("Configuration: " + json.dumps(resp["Configuration"]))
    
    # retrieving the Application ID, e.g. "ocid1.fnapp.oc1.phx.aaaaxxxx"
    appid = ctx.AppID()
    logging.getLogger().info("AppID: " + appid)
    resp["AppID"] = appid
    
    # retrieving the Function ID, e.g. "ocid1.fnfunc.oc1.phx.aaaaxxxxx"
    fnid = ctx.FnID()
    logging.getLogger().info("FnID: " + fnid)
    resp["FnID"] = fnid
    
    # retrieving the Function call ID, e.g. "01E9FE6JBW1BT0C68ZJ003KR1Q"
    callid = ctx.CallID()
    logging.getLogger().info("CallID: " + callid)
    resp["CallID"] = callid
    
    # retrieving the Function format, e.g. "http-stream"
    fnformat = ctx.Format()
    logging.getLogger().info("Format: " + fnformat)
    resp["Format"] = fnformat
    
    # retrieving the Function deadline, e.g. "2020-05-29T05:24:46Z"
    deadline = ctx.Deadline()
    logging.getLogger().info("Deadline: " + deadline)
    resp["Deadline"] = deadline
    
    logging.getLogger().info("function handler end")
    return response.Response(
        ctx, 
        response_data=json.dumps(resp),
        headers={"Content-Type": "application/json"}
    )         
            

Sie können nun Ihre Funktion erneut testen und die Ergebnisse anzeigen.

Mit Oracle Functions können Sie Konfigurationsdaten im Kontext speichern, der in Ihrer Anforderung verfügbar ist. Konfigurationsdaten können in einer Anwendung oder Funktion gespeichert werden. Die folgenden Befehle speichern Datenbankinformationen im Anwendungskontext.

• fn config app <your-app-name> DB-NAME your-db-name
• fn config app <your-app-name> DB-USER your-user-name

Weitere Informationen finden Sie im Tutorial zu Laufzeitkontext von Fn Project.

1. Stellen Sie die aktualisierte Funktion erneut bereit.
2. Rufen Sie die Funktion auf, um sicherzustellen, dass sie funktioniert.
3. Führen Sie Ihr Skript erneut aus. Um eine formatierte JSON-Ausgabe abzurufen, verwenden Sie das Utility jq, das in Cloud Shell enthalten ist. Wenn Sie die Befehlszeilenschnittstelle verwenden, installieren Sie jq auf Ihrem lokalen Rechner.

   gtw01.sh | jq

   Die zurückgegebenen Daten sehen in etwa folgendermaßen aus:

   {
       "Headers": {
       "host": [
       "localhost",
       "ctr6kqbjpza5tjnzafaqpqif5i.apigateway.us-phoenix-1.oci.customer-oci.com"
       ],
       "user-agent": [
       "lua-resty-http/0.14 (Lua) ngx_lua/10015",
       "curl/7.64.1"
       ],
       "transfer-encoding": "chunked",
       "content-type": [
       "application/octet-stream",
       "application/octet-stream"
       ],
       "date": "Thu, 10 Dec 2020 01:35:43 GMT",
       "fn-call-id": "01ES54MAKK1BT0H50ZJ00NGX00",
       "fn-deadline": "2020-12-10T01:36:13Z",
       "accept": "*/*",
       "cdn-loop": "iQPgvPk4HZ74L-PRJqYw7A",
       "forwarded": "for=73.34.74.159",
       "x-forwarded-for": "73.34.74.159",
       "x-real-ip": "73.34.74.159",
       "fn-http-method": "GET",
       "fn-http-request-url": "/v1/http-info",
       "fn-intent": "httprequest",
       "fn-invoke-type": "sync",
       "oci-subject-id": "ocid1.apigateway.oc1.phx.0000000000000000000000000000000000000000000000000000",
       "oci-subject-tenancy-id": "ocid1.tenancy.oc1..aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "oci-subject-type": "resource",
       "opc-request-id": "/A79EAB4A240E93EB226366B190A494BC/01ES54MAK21BT0H50ZJ00NGWZZ",
       "x-content-sha256": "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=",
       "accept-encoding": "gzip"
       },
       "Configuration": {
       "PATH": "/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
       "HOSTNAME": "7747cc436a14",
       "FN_LISTENER": "unix:/tmp/iofs/lsnr.sock",
       "FN_CPUS": "125m",
       "FN_LOGFRAME_NAME": "01ES54E5RN00000000000001JF",
       "FN_LOGFRAME_HDR": "Opc-Request-Id",
       "FN_FORMAT": "http-stream",
       "DB-NAME": "your-db-name",
       "DB-USER": "your-user-name",
       "FN_APP_ID": "ocid1.fnapp.oc1.phx.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "FN_FN_ID": "ocid1.fnfunc.oc1.phx.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "FN_MEMORY": "256",
       "FN_TYPE": "sync",
       "OCI_RESOURCE_PRINCIPAL_RPST": "/.oci-credentials/rpst",
       "OCI_RESOURCE_PRINCIPAL_PRIVATE_PEM": "/.oci-credentials/private.pem",
       "OCI_RESOURCE_PRINCIPAL_VERSION": "2.2",
       "OCI_RESOURCE_PRINCIPAL_REGION": "us-phoenix-1",
       "OCI_REGION_METADATA": "{\"realmDomainComponent\":\"oraclecloud.com\",\"realmKey\":\"oc1\",\"regionIdentifier\":\"us-phoenix-1\",\"regionKey\":\"PHX\"}",
       "LANG": "C.UTF-8",
       "GPG_KEY": "E3FF2839C048B25C084DEBE9B26995E310250568",
       "PYTHON_VERSION": "3.8.5",
       "PYTHON_PIP_VERSION": "20.2.2",
       "PYTHON_GET_PIP_URL": "https://github.com/pypa/get-pip/raw/5578af97f8b2b466f4cdbebe18a3ba2d48ad1434/get-pip.py",
       "PYTHON_GET_PIP_SHA256": "d4d62a0850fe0c2e6325b2cc20d818c580563de5a2038f917e3cb0e25280b4d1",
       "PYTHONPATH": "/function:/python",
       "HOME": "/home/fn"
       },
       "Request body": {},
       "Request URL": "/v1/http-info",
       "Query String": {},
       "Request Method": "GET",
       "AppID": "ocid1.fnapp.oc1.phx.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "FnID": "ocid1.fnfunc.oc1.phx.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "CallID": "01ES54MAKK1BT0H50ZJ00NGX00",
       "Format": "http-stream",
       "Deadline": "2020-12-10T01:36:13Z"
   }
                   
               

   Beachten Sie alle Functions-Daten, die in der zweiten Hälfte der Antwort zurückgegeben werden, einschließlich AppID, FnID und Format. Außerdem werden im Abschnitt Konfiguration die von Functions generierten Umgebungsvariablen (z.B. FN_FORMAT) sowie die Konfigurationsvariablen DB-NAME und DB-USER angezeigt.

4. Aktualisieren Sie Ihr Skript, um Header und POST-Daten an das Skript zu übergeben.

   /bin/bash
   curl -X POST --header "X-MyHeader1: headerValue" -d '{"key1":"value"}' https://aaaaa.apigateway.us-ashburn-X.oci.customer-oic.com/v1/http-info

   Die Ausgabe des Skripts sieht in etwa folgendermaßen aus:

   {
       "Headers": {
       "host": [
       "localhost",
       "ctr6kqbjpza5tjnzafaqpqif5i.apigateway.us-phoenix-1.oci.customer-oci.com"
       ],
       "user-agent": [
       "lua-resty-http/0.14 (Lua) ngx_lua/10015",
       "curl/7.64.1"
       ],
       "transfer-encoding": "chunked",
       "content-type": [
       "application/x-www-form-urlencoded",
       "application/x-www-form-urlencoded"
       ],
       "date": "Thu, 10 Dec 2020 17:05:14 GMT",
       "fn-call-id": "000000000000000000000000000",
       "fn-deadline": "2020-12-10T17:05:44Z",
       "accept": "*/*",
       "cdn-loop": "iQPgvPk4HZ74L-PRJqYw7A",
       "content-length": "16",
       "forwarded": "for=73.34.74.159",
       "x-forwarded-for": "73.34.74.159",
       "x-myheader1": "headerValue",
       "x-real-ip": "73.34.74.159",
       "fn-http-method": "POST",
       "fn-http-request-url": "/v1/http-info",
       "fn-intent": "httprequest",
       "fn-invoke-type": "sync",
       "oci-subject-id": "ocid1.apigateway.oc1.phx.0000000000000000000000000000000000000000000000000000",
       "oci-subject-tenancy-id": "ocid1.tenancy.oc1..aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "oci-subject-type": "resource",
       "opc-request-id": "/32DE93ED4A72B932E62460362A24DA40/01ES6STAH91BT0G48ZJ00J07ZT",
       "x-content-sha256": "xMAO2Qww/EVSr1CsSxtHsZu9VicSjb2EMvMmDMjZcVA=",
       "accept-encoding": "gzip"
       },
       "Configuration": {
       "PATH": "/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
       "HOSTNAME": "1afb03686740",
       "FN_LISTENER": "unix:/tmp/iofs/lsnr.sock",
       "FN_CPUS": "125m",
       "FN_APP_ID": "ocid1.fnapp.oc1.phx.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "FN_FN_ID": "ocid1.fnfunc.oc1.phx.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "FN_MEMORY": "256",
       "FN_TYPE": "sync",
       "FN_FORMAT": "http-stream",
       "DB-NAME": "your-db-name",
       "DB-USER": "your-user-name",
       "FN_LOGFRAME_NAME": "01ES6SSJY600000000000000BF",
       "FN_LOGFRAME_HDR": "Opc-Request-Id",
       "OCI_RESOURCE_PRINCIPAL_RPST": "/.oci-credentials/rpst",
       "OCI_RESOURCE_PRINCIPAL_PRIVATE_PEM": "/.oci-credentials/private.pem",
       "OCI_RESOURCE_PRINCIPAL_VERSION": "2.2",
       "OCI_RESOURCE_PRINCIPAL_REGION": "us-phoenix-1",
       "OCI_REGION_METADATA": "{\"realmDomainComponent\":\"oraclecloud.com\",\"realmKey\":\"oc1\",\"regionIdentifier\":\"us-phoenix-1\",\"regionKey\":\"PHX\"}",
       "LANG": "C.UTF-8",
       "GPG_KEY": "E3FF2839C048B25C084DEBE9B26995E310250568",
       "PYTHON_VERSION": "3.8.5",
       "PYTHON_PIP_VERSION": "20.2.2",
       "PYTHON_GET_PIP_URL": "https://github.com/pypa/get-pip/raw/5578af97f8b2b466f4cdbebe18a3ba2d48ad1434/get-pip.py",
       "PYTHON_GET_PIP_SHA256": "d4d62a0850fe0c2e6325b2cc20d818c580563de5a2038f917e3cb0e25280b4d1",
       "PYTHONPATH": "/function:/python",
       "HOME": "/home/fn"
       },
       "Request body": {
       "key1": "value"
       },
       "Request URL": "/v1/http-info",
       "Query String": {},
       "Request Method": "POST",
       "AppID": "ocid1.fnapp.oc1.phx.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "FnID": "ocid1.fnfunc.oc1.phx.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
       "CallID": "000000000000000000000000000",
       "Format": "http-stream",
       "Deadline": "2020-12-10T17:05:44Z"
   }

   Notieren Sie die Daten des Headers und des Anforderungsbodys. Die JSON-Schlüssel-/Wert-Daten werden im Abschnitt "Anforderungsbody" aufgeführt. Sie können den vollständigen Quellcode für die Funktion auf der Website für Oracle Functions-Beispiele herunterladen.

Herzlichen Glückwunsch. Sie haben die Python-Boilerplate-Funktion in eine neue Funktion konvertiert, die HTTP-Daten und Oracle Functions-Daten zurückgibt. Die Funktion zeigt, wie Daten an API Gateway übergeben und in einer Funktion verarbeitet werden können.