Funzioni: chiamare una funzione utilizzando API Gateway

• Un account a pagamento Oracle Cloud Infrastructure. Vedere Iscrizione a Oracle Cloud Infrastructure.
• L'account OCI configurato per supportare lo sviluppo di Oracle Functions. Vedere Oracle Functions on Cloud Shell Quickstart.
• Completamento di uno dei due tutorial introduttivi di Oracle Functions.
  • Funzioni: iniziare a utilizzare Cloud Shell
  • Funzioni: iniziare a utilizzare l'interfaccia CLI
• Il completamento di uno dei due tutorial comporta:
  • Oracle Functions viene impostato e configurato per creare applicazioni e distribuire funzioni.
  • Oracle Registry è impostato per memorizzare le immagini delle funzioni.
  • Docker viene collegato a Oracle Registry.
  • La VCN richiesta e le risorse necessarie per Oracle Functions.
  • Coppia di chiavi API e token di autenticazione.

CLI Oracle

• Python 3.6+ e pip3.
• Motore Docker: un computer Linux o una VM Linux. Per le versioni e le distribuzioni supportate, vedere Requisiti del motore Docker.
• Desktop Docker: disponibile per MacOS o Windows 10.
  • Windows 10: Windows 10 aggiornamento 2004 con WSL 2 e Ubuntu o altra distribuzione installata.
    • Vedere Windows Subsystem for Linux Installation Guide for Windows 10.
    • Installare Docker Desktop per Windows 10.
    Nota
    
    Docker include un supporto speciale per Linux per WSL 2 su Windows 10 update 2004.
  • MacOS: vedere Installa Docker Desktop per MacOS.

Oracle Cloud Shell

• Se si utilizza Cloud Shell, la lista di software precedente è già installata.

Per creare un compartimento, vedere Creare un compartimento. Dopo aver creato il compartimento, salvare l'OCID e il nome del compartimento.

Per ottenere l'OCID compartimento da un compartimento esistente, effettuare le operazioni riportate di seguito.

1. Aprire il menu di navigazione e fare clic su Identità e sicurezza. In Identità fare clic su Compartimenti.
2. Selezionare il compartimento.
3. Fare clic sul collegamento Copia per il campo OCID.

Salvare l'OCID e il nome del compartimento.

Assicurarsi di disporre delle seguenti informazioni scritte per l'esercitazione.

• Nome compartimento: <your-compartment-name>

  Esempio: my-compartment

• ID compartimento: <your-compartment-OCID>

  Esempio: ocid1.compartment.oc1.aaaaaaa...

• Nome VCN: <your-vcn-name>

  Esempio: my-vcn

  Aprire il menu di navigazione e fare clic su Rete, quindi fare clic su Reti cloud virtuali. Dall'elenco delle reti, selezionare la VCN.

• Nome subnet pubblica VCN: <Public-Subnet-your-vcn-name>

  Esempio: Public-Subnet-my-vcn

  Aprire il menu di navigazione e fare clic su Rete, quindi fare clic su Reti cloud virtuali. Dall'elenco delle reti, selezionare la VCN.

Per creare un'applicazione, procedere come segue.

1. Aprire il menu di navigazione e fare clic su Servizi per sviluppatori. In Funzioni, fare clic su Applicazioni.
2. Selezionare il compartimento dall'elenco a discesa Compartimento.
3. Fare clic su Create Application.
4. Compilare i dati del modulo.
   • Nome: <your-app-name>
   • VCN: <your-vcn-name>
   • Subnet: <Public-Subnet-your-vcn-name>
5. Fare clic su Crea.

L'applicazione è stata creata.

1. Aprire il menu di navigazione e fare clic su Rete, quindi fare clic su Reti cloud virtuali.
2. Fare clic sul nome della VCN utilizzata per l'applicazione Oracle Functions.
3. Con la nuova VCN visualizzata, fare clic sul collegamento della subnet Pubblica.

   Le informazioni sulla subnet pubblica vengono visualizzate con gli elenchi di sicurezza nella parte inferiore della pagina.

4. Fare clic sul collegamento Lista di sicurezza predefinita o sul collegamento appropriato della lista di sicurezza.

   Vengono visualizzate le regole di entrata predefinite per la VCN.

5. Fare clic su Aggiungi regole di entrata.

   Viene visualizzata la finestra di dialogo Aggiungi regole di entrata.

6. Compilare la regola di entrata con le seguenti informazioni. Dopo aver immesso tutti i dati, fare clic su Aggiungi regole di entrata

   Compilare la regola di entrata come indicato di seguito.

   • Stateless: controllato
   • Tipo di origine: CIDR
   • CIDR di origine: 0.0.0.0/0
   • Protocollo IP: TCP
   • Intervallo porte di origine: (lasciare vuoto)
   • Intervallo di porte di destinazione: 443
   • Descrizione: VCN per le applicazioni

   Dopo aver fatto clic su Aggiungi regola di entrata, le connessioni HTTPS sono consentite alla subnet pubblica.

Successivamente, imposta un criterio che consenta al gateway API di richiamare le funzioni.

In primo luogo, creare un gruppo dinamico per il gateway API.

1. Aprire il menu di navigazione e fare clic su Identità e sicurezza. In Identità fare clic su Gruppi dinamici.
2. Fare clic su Crea gruppo dinamico.
3. Inserire le seguenti informazioni per definire il gruppo dinamico.
   • Nome: <name-for-your-dynamic-group>
   • In Regole di corrispondenza utilizzare Regola 1: <the-rule-text>

   Di seguito è riportato il nome di esempio e la regola da compilare. Sostituire <your-compartment-OCID> con il relativo valore.

   • Nome: api-gtw-func-dynamic-group
   • In Regole di corrispondenza utilizzare Regola 1: ALL {resource.type = 'ApiGateway', resource.compartment.id = '<your-compartment-OCID>'}
4. Fare clic su Crea.

Ora crea il criterio per il gateway API.

1. Aprire il menu di navigazione e fare clic su Identità e sicurezza. In Identità fare clic su Criteri.
2. Fare clic su Create Policy.
3. Per definire la polizza, inserire le seguenti informazioni.
   • Nome: <name-for-your-policy>
   • Descrizione: <description-for policy>
   • Compartimento: <name-of-functions-compartment>

   Per la sezione Policy Builder:

   • Fare clic su Mostra editor manuale.
   • Immettere il criterio nella casella di testo, ad esempio:

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

     Nota
     
     L'ultimo parametro è il nome del compartimento, non l'OCID del compartimento.
4. Fare clic su Crea.

È stato creato un criterio per consentire al gateway API di utilizzare le funzioni.

1. Aprire un terminale.
2. Creare una directory in cui memorizzare le funzioni e passare a tale directory.

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

3. Crea una funzione "Hello World" Python con Fn.

   fn init --runtime python my-func-name

   Questo comando crea una directory denominata my-func-name contenente i file di funzione e configurazione.

4. Passare alla directory.
5. Distribuire la funzione.

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

   Vengono visualizzati vari messaggi quando le immagini Docker vengono create, sottoposte a push in OCIR e infine distribuite in Oracle Functions.

6. Richiama la funzione.

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

   Restituisce: {"message": "Hello World"}

7. Richiama la funzione con un parametro.

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

   Restituisce: {"message": "Hello Bob"}

Per creare un gateway API:

1. Aprire il menu di navigazione e fare clic su Servizi per sviluppatori. In Gestione API, fare clic su Gateway.
2. Selezionare il compartimento dall'elenco a discesa Compartimento.
3. Fare clic su Crea gateway.
4. Inserire le informazioni riportate di seguito per definire il gateway API.
   • Nome: <your-gateway-name>
   • Tipo: <Public>
   • Compartimento: <your-compartment-name>
   • Rete cloud virtuale in <your-vcn-name>: <select-your-vcn>
   • Subnet in <your-compartment-name: <your-public-subnet-name>
5. Fare clic su Crea. Attendere alcuni minuti per la creazione del gateway API.

Successivamente, crea una distribuzione per il gateway API.

1. Fare clic su Distribuzioni nella sezione Risorse sul lato sinistro della schermata.
2. Fare clic su Crea distribuzione.
3. Assicurarsi che l'opzione Da zero sia selezionata per il tipo di distribuzione.
4. Per definire la distribuzione, compilare la sezione Informazioni di base.
   • Nome: <your-deployment-name>
   • Prefisso percorso (esempio): /v1
   • Compartimento: <your-compartment-name>
   • Criteri di richiesta API: adotta i valori predefiniti
   • Criteri di registrazione API: prendi il valore predefinito di Information
5. Fare clic su Successivo. Viene visualizzata la finestra di dialogo Cicli con l'opzione Ciclo 1 selezionata.
6. Per definire l'instradamento, compilare la sezione Instradamento 1.
   • Percorso: <your-route-path>

     Esempio: /http-info

   • Metodi: GET POST
   • Tipo: Oracle Functions
   • Applicazione in <your-compartment-name>: selezionare l'applicazione Funzioni creata.
   • Nome funzione: selezionare la funzione creata nella sezione di configurazione.
7. Fare clic su Successivo. Viene visualizzata la finestra di dialogo Revisione con un riepilogo delle scelte effettuate.
8. Fare clic su Crea. La distribuzione è stata creata.
9. Fare clic sul collegamento Distribuzioni per il gateway. Copiare l'endpoint di base per la distribuzione creata.

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

Con il gateway API e la distribuzione creati, è ora possibile eseguire il test dell'installazione. Creare uno script semplice per il comando curl. Per creare l'URL per curl, aggiungere il percorso di distribuzione all'endpoint.

1. Creare il file di script: touch gtw01.sh && chmod 755 gtw01.sh
2. Aggiungere il comando curl al file di script:

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

3. Il comando restituisce: {"message":"Hello World"}

Hai connesso il tuo gateway API a una funzione Python di boiler plate. Successivamente, si aggiorna la funzione Python per visualizzare le informazioni passate in una richiesta HTTP.

Se si guarda alla funzione piastra caldaia, la funzione Python ha un aspetto simile a questo.

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"}
    )

Usando questo codice come punto di partenza, le sezioni che seguono convertono la funzione in una funzione Python che restituisce HTTP e i dati di configurazione.

In primo luogo, aggiornare la funzione per i pacchetti richiesti.

1. Aggiornare il file requirements.txt per il pacchetto oci.

   fdk
   oci                    
                   

2. Aggiornare le istruzioni import in func.py per i pacchetti richiesti per le funzioni HTTP:

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

   Il package oci è obbligatorio per alcune richieste di contesto. I pacchetti urlparse, parse_qs vengono utilizzati per l'analisi.

In primo luogo, rimuovere il corpo principale della funzione. Il metodo response e il codice correlato vengono aggiunti di nuovo.

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):                
            

Aggiungere quindi il codice per visualizzare le informazioni HTTP nella risposta. Ecco il codice con i commenti che seguono.

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

• La funzione handler riceve informazioni di sistema sulla richiesta corrente tramite i parametri ctx e data.
• Tutti i dati vengono aggiunti al dizionario resp che viene restituito nella risposta.
• Si noti che il contesto di runtime della funzione (ctx) contiene gran parte dei dati HTTP passati da una richiesta, tra cui intestazioni, URL della richiesta e metodo.
• Il parametro data restituisce il corpo della richiesta.

Successivamente, recuperare i dati correlati a Oracle Functions dal contesto, quindi restituire una risposta. Seguono i commenti.

    # 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"}
    )

Si noti che tutti i dati relativi alle funzioni vengono recuperati dall'oggetto ctx, tra cui AppID, FnID e Format.

Ecco il codice funzione finale.

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"}
    )         
            

Ora sei pronto per provare di nuovo a funzionare e vedere i risultati.

Oracle Functions consente di memorizzare i dati di configurazione nel contesto disponibile nella richiesta. I dati di configurazione possono essere memorizzati in un'applicazione o in una funzione. I comandi seguenti memorizzano le informazioni sul database nel contesto dell'applicazione.

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

Per ulteriori informazioni, vedere l'esercitazione di Fn Project sul contesto di runtime.

1. Ridistribuire la funzione aggiornata.
2. Richiamare la funzione per assicurarsi che la funzione funzioni.
3. Eseguire nuovamente lo script. Per ottenere l'output JSON formattato, utilizzare la utility jq inclusa nella shell cloud shell. Se si utilizza l'interfaccia CLI, installare jq sul sistema locale.

   gtw01.sh | jq

   I dati restituiti sono simili a:

   {
       "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"
   }
                   
               

   Notare tutti i dati delle funzioni restituiti nella seconda metà della risposta, inclusi: AppID, FnID e Format. Inoltre, nella sezione Configuration vengono visualizzate le variabili di ambiente generate dalle funzioni come FN_FORMAT e le variabili di configurazione: DB-NAME e DB-USER.

4. Aggiornare lo script per passare intestazioni e dati POST allo script.

   /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

   L'output dello script è simile al seguente:

   {
       "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"
   }

   Prendere nota dei dati dell'intestazione e del corpo della richiesta. I dati JSON chiave/valore vengono elencati nella sezione "Corpo della richiesta". È possibile scaricare il codice sorgente completo per la funzione dal sito Esempi di funzioni Oracle qui.

Congratulazioni, la funzione Python della piastra di caldaia è stata convertita in una nuova funzione che restituisce i dati HTTP e Oracle Function. La funzione dimostra come i dati possono essere passati al gateway API ed elaborati in una funzione.