Oracle Functions : Appeler une fonction à l'aide de la passerelle d'API

• Un compte Oracle Cloud Infrastructure payant. Voir Inscription à Oracle Cloud Infrastructure.
• Un compte OCI configuré pour prendre en charge le développement avec Oracle Functions. Voir Démarrage rapide avec Oracle Functions sur Cloud Shell.
• Vous devez avoir suivi l'un des deux tutoriels d'introduction à Oracle Functions.
  • Oracle Functions : Démarrer avec Cloud Shell
  • Oracle Functions : Démarrer à l'aide de la CLI
• Voici les résultats obtenus après l'exécution de ces deux tutoriels :
  • Oracle Functions est configuré pour créer des applications et déployer des fonctions.
  • Oracle Registry est configuré pour stocker des images de fonction.
  • Docker est connecté à Oracle Registry.
  • Vous disposez du VCN requis et des ressources requises pour Oracle Functions.
  • Vous disposez d'une paire de clés d'API et d'un jeton d'authentification.

Interface de ligne de commande Oracle

• Python 3.6+ et pip3.
• Moteur Docker : Ordinateur Linux ou machine virtuelle Linux. Voir les exigences en matière de moteur Docker pour connaître les versions et les distributions prises en charge.
• Docker Desktop : Disponible pour MacOS ou Windows 10.
  • Windows 10 : Mise à jour Windows 10 2004 avec WSL 2 et Ubuntu ou toute autre distribution installée.
    • Consultez le guide d'installation du sous-système Windows pour Linux sous Windows 10.
    • Installez Docker Desktop pour Windows 10.
    Note
    
    Docker inclut une prise en charge spéciale de Linux pour WSL 2 sous la mise à jour Windows 10 2004.
  • MacOS : Consultez la page relative à l'installation de Docker Desktop pour MacOS.

Oracle Cloud Shell

• Si vous utilisez Cloud Shell, les logiciels répertoriés dans la liste précédente sont déjà installés.

Pour créer un compartiment, voir Créer un compartiment. Une fois votre compartiment créé, enregistrez son OCID et son nom.

Pour obtenir l'OCID du compartiment à partir d'un compartiment existant :

1. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Compartiments.
2. Sélectionnez votre compartiment.
3. Cliquez sur le lien Copier pour le champ OCID.

Enregistrez l'OCID et le nom du compartiment.

Notez les informations suivantes pour le tutoriel.

• Nom du compartiment : <your-compartment-name>

  Exemple : mon compartiment

• ID compartiment : <your-compartment-OCID>

  Exemple : ocid1.compartment.oc1.aaaaaaa...

• Nom du VCN : <your-vcn-name>

  Exemple : mon VCN

  Ouvrez le menu de navigation et cliquez successivement sur Service de réseau et Réseaux en nuage virtuels. Dans la liste des réseaux, sélectionnez votre VCN.

• Nom du sous-réseau public du réseau VCN : <Public-Subnet-your-vcn-name>

  Exemple : Public-Subnet-my-vcn

  Ouvrez le menu de navigation et cliquez successivement sur Service de réseau et Réseaux en nuage virtuels. Dans la liste des réseaux, sélectionnez votre VCN.

Pour créer une application, procédez de la façon suivante.

1. Ouvrez le menu de navigation et cliquez sur Services de développement. Sous Fonctions, cliquez sur Applications.
2. Sélectionnez votre compartiment dans la liste déroulante Compartiments.
3. Cliquez sur Créer une application.
4. Complétez le formulaire.
   • Nom : <your-app-name>
   • VCN : <your-vcn-name>
   • Sous-réseaux : <Public-Subnet-your-vcn-name>
5. Cliquez sur Créer.

Votre application est créée.

1. Ouvrez le menu de navigation et cliquez successivement sur Service de réseau et Réseaux en nuage virtuels.
2. Cliquez sur le nom du VCN que vous avez utilisé pour votre application Oracle Functions.
3. Maintenant que votre nouveau VCN est affiché, cliquez sur le lien de sous-réseau Public.

   Les informations sur le sous-réseau public s'affichent avec les listes de sécurité au bas de la page.

4. Cliquez sur le lien Liste de sécurité par défaut ou sur le lien de liste de sécurité approprié.

   Les règles de trafic entrant par défaut pour votre VCN s'affichent.

5. Cliquez sur Ajouter des règles de trafic entrant.

   Une boîte de dialogue Ajouter des règles de trafic entrant s'affiche.

6. Entrez les informations suivantes pour la règle de trafic entrant. Une fois toutes les données entrées, cliquez sur Ajouter des règles de trafic entrant

   Définissez la règle de trafic entrant comme suit :

   • Sans état : Coché
   • Type de source : CIDR
   • CIDR source : 0.0.0.0/0
   • Protocole IP : TCP
   • Intervalle de ports sources : (Laissez vide)
   • Intervalle de ports de destination : 443
   • Description : VCN pour les applications

   Après que vous avez cliqué sur Ajouter une règle de trafic entrant, les connexions HTTPS à votre sous-réseau public sont autorisées.

À présent, configurez une politique qui permet à la passerelle d'API d'appeler des fonctions.

Commencez par créer un groupe dynamique pour la passerelle d'API.

1. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Groupes dynamiques.
2. Cliquez sur Créer un groupe dynamique.
3. Indiquez les informations suivantes pour définir votre groupe dynamique.
   • Nom : <name-for-your-dynamic-group>
   • Sous Règles de correspondance, utilisez Règle 1 : <the-rule-text>

   Voici le nom d'exemple et la règle que vous devez entrer. Remplacez <your-compartment-OCID> par sa valeur.

   • Nom : api-gtw-func-dynamic-group
   • Sous Règles de correspondance, utilisez Règle 1 : Tout {resource.type = 'ApiGateway', resource.compartment.id = '<your-compartment-OCID>'}
4. Cliquez sur Créer.

À présent, créez la politique pour la passerelle d'API.

1. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Politiques.
2. Cliquez sur Créer une politique.
3. Pour définir votre politique, entrez les informations suivantes.
   • Nom : <name-for-your-policy>
   • Description : <description-for policy>
   • compartiment : <name-of-functions-compartment>

   Pour la section Générateur de politiques :

   • Cliquez sur Afficher l'éditeur manuel.
   • Entrez votre politique dans la zone de texte, par exemple :

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

     Note
     
     Le dernier paramètre est le nom et non l'OCID du compartiment.
4. Cliquez sur Créer.

Vous avez créé une politique pour permettre à la passerelle d'API d'utiliser le service des fonctions.

1. Ouvrez une fenêtre de terminal.
2. Créez un répertoire dans lequel stocker vos fonctions et accédez à ce répertoire.

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

3. Créez une fonction Python "Hello World" avec Fn.

   fn init --runtime python my-func-name

   Cette commande crée un répertoire nommé my-func-name contenant la fonction et des fichiers de configuration.

4. Accédez au répertoire.
5. Déployez la fonction.

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

   Divers messages s'affichent au fur et à mesure que les images Docker sont créées, poussées vers OCIR, puis déployées dans Oracle Functions.

6. Appelez la fonction.

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

   Retourne : {"message": "Hello World"}

7. Appelez la fonction avec un paramètre.

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

   Retourne : {"message": "Hello Bob"}

Pour créer une passerelle d'API :

1. Ouvrez le menu de navigation et cliquez sur Services de développement. Sous Gestion d'API, cliquez sur Passerelles.
2. Sélectionnez votre compartiment dans la liste déroulante Compartiments.
3. Cliquez sur Créer une passerelle
4. Indiquez les informations suivantes pour définir votre passerelle d'API.
   • Nom : <your-gateway-name>
   • Type : <Public>
   • compartiment : <your-compartment-name>
   • Réseau en nuage virtuel dans <your-vcn-name>: <select-your-vcn>
   • Sous-réseau dans <your-compartment-name: <your-public-subnet-name>
5. Cliquez sur Créer. Attendez quelques minutes que votre passerelle d'API soit créée.

À présent, créez un déploiement pour votre passerelle d'API.

1. Cliquez sur Déploiements dans la section Ressources située dans la partie gauche de l'écran.
2. Cliquez sur Créer un déploiement.
3. Assurez-vous que À partir de zéro est sélectionné pour le type de déploiement.
4. Pour définir votre déploiement, renseignez la section Informations de base.
   • Nom : <your-deployment-name>
   • Préfixe de chemin (exemple) : /v1
   • compartiment : <your-compartment-name>
   • Politiques de demande d'API : Utilisez les valeurs par défaut
   • Politiques de journalisation d'API : Utilisez la valeur par défaut Informations
5. Cliquez sur Suivant. La boîte de dialogue Routes s'affiche avec la valeur Route 1 sélectionnée.
6. Pour définir votre route, renseignez la section Route 1.
   • Chemin : <your-route-path>

     Exemple : /http-info

   • Modes : GET POST
   • Type : Oracle Functions
   • Application dans <your-compartment-name> : Sélectionnez l'application Oracle Functions que vous avez créée.
   • Nom de la fonction : Sélectionnez la fonction que vous avez créée à la section de configuration.
7. Cliquez sur Suivant. La boîte de dialogue Vérifier récapitulant les choix que vous avez faits s'affiche.
8. Cliquez sur Créer. Votre déploiement est créé.
9. Cliquez sur le lien Déploiements pour votre passerelle. Copiez le point d'extrémité de base pour le déploiement que vous avez créé.

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

Maintenant que votre passerelle d'API et votre déploiement sont créés, vous pouvez tester votre installation. Créez un script simple pour la commande curl. Pour créer l'URL de curl, ajoutez votre chemin de déploiement à votre point d'extrémité.

1. Créez le fichier de script : touch gtw01.sh && chmod 755 gtw01.sh
2. Ajoutez la commande curl au fichier de script :

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

3. La commande retourne : {"message":"Hello World"}

Vous avez connecté votre passerelle d'API à une fonction Python standard. À présent, vous allez mettre à jour votre fonction Python pour afficher les informations transmises dans une demande HTTP.

Si vous examinez la fonction Python standard, elle ressemble à ceci.

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

Avec ce code comme point de départ, les sections suivantes convertissent la fonction en une fonction Python qui retourne les données HTTP et de configuration.

Commencez par mettre à jour la fonction avec les ensembles requis.

1. Mettez à jour le fichier requirements.txt avec l'ensemble oci.

   fdk
   oci                    
                   

2. Mettez à jour les énoncés import dans func.py avec les ensembles requis pour les fonctions HTTP :

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

   L'ensemble oci est requis pour certaines demandes de contexte. Les ensembles urlparse, parse_qs sont utilisés à des fins d'analyse.

Commencez par supprimer le corps principal de la fonction. La méthode response et le code connexe seront ajoutés à nouveau au fur et à mesure.

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

Ensuite, ajoutez le code pour afficher les informations HTTP dans la réponse. Voici le code avec des commentaires.

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 fonction handler reçoit des informations système sur la demande courante au moyen des paramètres ctx et data.
• Toutes les données sont ajoutées au dictionnaire resp qui sera ensuite retourné dans la réponse.
• Notez que le contexte d'exécution de la fonction (ctx) contient une grande partie des données HTTP transmises à partir d'une demande, y compris les en-têtes, l'URL de demande et la méthode.
• Le paramètre data renvoie le corps de la demande.

À présent, extrayez les données liées à Oracle Functions du contexte, puis retournez une réponse. Voici les commentaires.

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

Notez que toutes les données liées à Oracle Functions sont extraites de l'objet ctx, y compris : AppID, FnID et Format.

Voici le code de fonction terminé.

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

À présent, vous pouvez tester à nouveau votre fonction et voir les résultats.

Oracle Functions vous permet de stocker les données de configuration dans le contexte disponible dans votre demande. Il est possible de stocker les données de configuration dans une application ou une fonction. Les commandes suivantes stockent les informations de base de données dans le contexte d'application.

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

Pour plus d'informations, voir le tutoriel d'utilisation du contexte d'exécution Fn avec des fonctions.

1. Redéployez la fonction mise à jour.
2. Appelez la fonction pour vous assurer qu'elle fonctionne.
3. Réexécutez votre script. Pour obtenir la sortie JSON formatée, recourez à l'utilitaire jq qui est inclus dans Cloud Shell. Si vous utilisez l'interface CLI, installez jq sur votre machine locale.

   gtw01.sh | jq

   Les données retournées ressemblent à celles-ci :

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

   Notez toutes les données Oracle Functions retournées dans la seconde moitié de la réponse, y compris: AppID, FnID et Format. De plus, dans la section Configuration, vous voyez les variables d'environnement générées par Oracle Functions, telles que FN_FORMAT, et les variables de configuration : DB-NAME et DB-USER.

4. Mettez à jour votre script pour transmettre les en-têtes ainsi que les données POST au 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

   La sortie du script ressemble à celle-ci :

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

   Notez les données d'en-tête et les données du corps de la demande. Les données JSON clé-valeur sont listées dans la section "Request body". Vous pouvez télécharger le code source complet de la fonction à partir du site des échantillons pour Oracle Functions.

Félicitations, vous avez converti la fonction Python standard en une nouvelle fonction qui retourne des données HTTP et Oracle Functions. La fonction montre comment des données peuvent être transmises à la passerelle d'API et traitées dans une fonction.