Documentation Oracle Cloud Infrastructure

Functions : démarrage à l'aide de l'interface de ligne de commande

Dans ce tutoriel, vous utilisez un compte Oracle Cloud Infrastructure pour configurer le développement Oracle Functions. Ensuite, vous créez une application de fonction et une fonction.

Les principales tâches expliquent comment :

  • configurer un jeton d'authentification,
  • collecter les informations requises,
  • configurer un réseau cloud virtuel,
  • configurer OCI Registry (OCIR),
  • configurer l'interface de ligne de commande pour déployer des fonctions,
  • configurer le contexte Fn,
  • créer une application pour la fonction Oracle,
  • créer une fonction,
  • déployer la fonction,
  • tester la fonction.
L'image présente les composants OCI utilisés pour exécuter les fonctions Oracle.

Pour plus d'informations, voir :

Avant de commencer

Pour suivre ce tutoriel, vous avez besoin des éléments suivants :

Exigences relatives au compte OCI
Exigences logicielles

1. Collecte des informations requises

Collectez toutes les informations nécessaires pour effectuer le tutoriel.

Collecte des informations sur la région et sur le registre

Préparez les informations dont vous avez besoin à partir de la console OCI.

  1. Recherchez l'identificateur de région et la clé de région dans Régions et domaines de disponibilité.

    Exemple : us-ashburn-1 et iad pour Ashburn.

  2. Créez un nom de projet de registre pour stocker les images de fonction dans OCI Registry (OCIR).

    Lorsque vous publiez une fonction, une image Docker est créée dans OCIR. Le nom du projet OCIR est ajouté au début du nom des images de fonction afin de faciliter leur recherche. Par exemple :

    • Nom du projet de registre : my-func-prj
    • Nom de la fonction : node-func

    L'image de fonction est stockée sur OCIR sous : my-func-prj/node-func

Création ou sélection d'un compartiment

Pour créer un compartiment, reportez-vous à Création d'un compartiment. Une fois le compartiment créé, enregistrez son OCID.

Pour obtenir l'OCID d'un compartiment existant, procédez comme suit :

  1. Ouvrez le menu de navigation et cliquez sur Identité et sécurité. Sous Identité, cliquez sur Compartiments.
  2. Sélectionnez le compartiment.
  3. Cliquez sur le lien Copier du champ OCID.
Création d'un jeton d'autorisation

Créez un jeton d'autorisation pour vous connecter à OCI Registry. Pour créer un jeton d'autorisation, procédez comme suit :

  1. Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres utilisateur ou Mon profil, en fonction de l'option que vous voyez.
  2. Cliquez sur Jetons d'authentification.
  3. Cliquez sur Générer un jeton.
  4. Indiquez une description.
  5. Cliquez sur Générer un jeton.
  6. Copiez le jeton et enregistrez-le.
    Remarque

    Veillez à enregistrer le jeton dès qu'il est créé. Vous ne pourrez plus y accéder ultérieurement.
Collecte des informations

Collectez toutes les informations nécessaires pour effectuer le tutoriel. Copiez les informations suivantes dans votre bloc-notes.

  1. Région : <region-identifier>

    Exemple : us-ashburn-1.

  2. Clé de région : <region-key>

    Exemple : iad.

  3. Nom du projet de registre : <nom-du-projet>

    Exemple : my-func-prj.

  4. ID de compartiment : <compartment-id>

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

  5. Jeton d'authentification : <auth-token>

    Exemple : ABC.1aBC...

  6. Nom de location : <tenancy-name>

    A partir de l'avatar utilisateur, par exemple : mytenancyname

  7. OCID de la location : <tenancy-ocid>

    A partir de l'avatar utilisateur, accédez à Location : <votre-location> et copiez l'OCID, par exemple : ocid1.tenancy.oc1.aaaaaaa...

  8. Nom utilisateur : <user-name>

    A partir de l'avatar utilisateur.

2. Création de votre réseau cloud virtuel

Configurez un réseau cloud virtuel pour connecter l'instance Linux à Internet. Configurez tous les composants nécessaires à la création du réseau virtuel.

Exécution de l'assistant de réseau cloud virtuel
  1. Cliquez sur l'icône Oracle Cloud pour accéder à la page de renvoi principale.
    • Faites défiler la page jusqu'à Ressources de lancement.
    • Sélectionnez Configurer un réseau à l'aide d'un assistant.
  2. Dans le workflow Lancer l'assistant de réseau cloud virtuel, sélectionnez Créer un réseau cloud virtuel avec une connectivité Internet, puis cliquez sur Lancer l'assistant de réseau cloud virtuel.
  3. Dans la boîte de dialogue de configuration, renseignez le nom du réseau cloud virtuel. Le compartiment est déjà défini sur le dernier compartiment que vous avez utilisé. Sinon, il est défini sur la valeur par défaut : <votre-location> (racine).
  4. Dans la section Configurer le réseau cloud virtuel et les sous-réseaux, conservez les valeurs par défaut des blocs CIDR :
    • BLOC CIDR DU VCN : 10.0.0.0/16
    • Bloc CIDR de sous-réseau public : 10.0.0.0.0/24
    • Bloc CIDR de sous-réseau privé : 10.0.1.0/24
    Remarque

    Les sous-réseaux public et privé ont des adresses réseau différentes.
  5. Pour Résolution DNS, désélectionnez Utiliser les noms d'hôte DNS dans ce réseau cloud virtuel.
  6. Cliquez sur Suivant.

    La boîte de dialogue de configuration Créer un réseau cloud virtuel avec une connectivité Internet apparaît (non illustrée ici) avec toutes les valeurs que vous venez de saisir.

  7. Pour créer le réseau cloud virtuel, cliquez sur Créer.

    La boîte de dialogue Création de ressources apparaît (non illustrée ici) avec tous les composants de réseau cloud virtuel en cours de création.

Ajout d'une règle de sécurité au réseau cloud virtuel
  1. Cliquez sur Afficher le réseau cloud virtuel pour afficher le nouveau réseau cloud virtuel.

    Le nouveau réseau cloud virtuel s'affiche. Vous devez maintenant ajouter une règle de sécurité pour autoriser les connexions HTTP sur le port 80, qui est le port par défaut de vos applications.

  2. Une fois le nouveau réseau cloud virtuel affiché, cliquez sur le lien du sous-réseau Public.

    Les informations sur le sous-réseau public sont affichées avec les listes de sécurité en bas de la page. Un lien vers la liste de sécurité par défaut du réseau cloud virtuel s'affiche.

  3. Cliquez sur le lien Liste de sécurité par défaut.

    Les règles entrantes par défaut du réseau cloud virtuel sont affichées.

  4. Cliquez sur Ajouter des règles entrantes.

    La boîte de dialogue Ajouter des règles entrantes apparaît.

  5. Renseignez la règle entrante avec les informations suivantes. Une fois toutes les données entrées, cliquez sur Ajouter des règles entrantes.

    Renseignez la règle entrante comme suit :

    • Sans conservation de statut : option cochée
    • Type de source : CIDR
    • CIDR source : 0.0.0.0/0
    • Protocole IP : TCP
    • Plage de ports source : (à laisser vide)
    • Plage de ports de destination : 80
    • Description : Réseau cloud virtuel pour les applications

    Une fois que vous avez cliqué sur Ajouter une règle entrante, les connexions HTTP sont autorisées sur le sous-réseau public.

Remarque

Pour ouvrir un autre port, remplacez 80 par le numéro de port souhaité dans la dernière étape.

Vous avez créé un réseau cloud virtuel qui rend les applications disponibles à partir d'Internet.

3. Configuration de l'interface de ligne de commande OCI

Pour développer des fonctions sur votre ordinateur local, vous devez configurer l'interface de ligne de commande (CLI) OCI. Cette section suppose que vous avez déjà installé Docker, Python 3.6+ et pip3.

Effectuez les étapes des trois sections suivantes pour activer le développement Oracle Functions sur votre ordinateur local à l'aide de l'interface de ligne de commande. Pour obtenir une explication détaillée de chaque étape, reportez-vous à la documentation sur la configuration d'Oracle Functions dans un environnement de développement local.

Configuration de l'interface de ligne de commande avec Python

La configuration de l'interface de ligne de commande vous permet de déployer vos fonctions et votre application de fonction vers OCI Registry à partir de votre ordinateur. Tout d'abord, installez l'interface de ligne de commande à l'aide de la fonctionnalité d'environnement virtuel de Python.

  1. Installez virtualenv :

    Avec un environnement virtuel, vous pouvez gérer les dépendances du projet. Chaque projet peut se trouver dans son propre environnement virtuel pour héberger des groupes indépendants de bibliothèques Python. Installez virtualenv et virtualenvwrapper.

    1. Ubuntu : 
      sudo pip3 install virtualenv
sudo pip3 install virtualenvwrapper
    2. Oracle Linux : si vous utilisez une image OCI Oracle Linux 7.8, Python 3.6 et pip3 sont inclus par défaut. Si vous utilisez une autre image Oracle Linux, les commandes permettant d'installer le référentiel de développement Oracle Linux avec Python 3.6 sont indiquées ci-après. Si Python 3.6 est déjà installé sur l'image, ignorez les deux premières commandes avant la commande pip3.
      sudo yum install oracle-epel-release-el7
sudo yum install python36
sudo pip3 install virtualenv
sudo pip3 install virtualenvwrapper
    3. macOS : lorsque vous installez Python 3 pour macOS, pip3 est installé. Vous pouvez donc installer des modules avec pip3.
      brew install python3
pip3 install pipenv
    Remarque

    Vous devrez peut-être saisir "y" plusieurs fois pour accepter les packages installés sur la machine virtuelle.
  2. Créez un répertoire pour stocker les environnements virtuels. Par exemple, mkdir ~/envs crée un répertoire envs sous le répertoire de base.
  3. Configurez le wrapper d'environnement virtuel dans .bashrc.

    Mettez à jour le fichier :

    sudo vi .bashrc
    Remarque

    Le chemin d'accès à l'exécutable Python et à virtualwrapper.sh peut varier en fonction du système d'exploitation ou de la distribution Linux. Veillez à utiliser le chemin correct avec la commande which.

    Ajoutez le texte ci-dessous à la fin du fichier, puis enregistrez ce dernier :

    # set up Python env
export WORKON_HOME=~/envs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
source /usr/local/bin/virtualenvwrapper.sh

    Activez les commandes précédentes dans la fenêtre active.

    source ~/.bashrc
  4. Démarrez un environnement virtuel. 
    mkvirtualenv cli-app
    Vous voyez un résultat semblable à ce qui suit : (cli-app) ubuntu@<nom-instance-ubuntu>:~$
  5. Installez l'interface de ligne de commande. 
    pip3 install oci-cli
Configuration de la connexion via l'interface de ligne de commande

Configurez l'interface de ligne de commande de sorte qu'elle puisse se connecter aux services OCI.

  1. Configurez le fichier de configuration de l'interface de ligne de commande. 
    oci setup config

    Entrez les informations de base : (utilisez les réponses de l'étape Collecte des informations requises.)

    • Emplacement de la configuration [$HOME/.oci/config] : <utiliser-valeur-par-défaut>
    • OCID utilisateur : <user-ocid>
    • OCID de la location : <tenancy-ocid>
    • Région (par exemple, us-ashburn-1) : <identificateur-de-région>

    Configurez les clés de cryptage d'API OpenSSL :

    • Générer une nouvelle paire de clés RSA de signature d'API ? [Y/N] : Y
    • Répertoire pour les clés [$HOME/.oci] : <utiliser-valeur-par-défaut>
    • Nom de la clé [oci_api_key] <utiliser-valeur-par-défaut>
    Remarque

    La clé privée est oci_api_key.pem et la clé publique est oci_api_key_public.pem.
  2. Copiez la clé publique.
    Dans le terminal, saisissez ce qui suit :
    cat $HOME/.oci/oci_api_key_public.pem
  3. Ajoutez la clé publique à votre compte utilisateur.
    • Dans la barre de navigation, sélectionnez le menu Profil, puis sélectionnez Paramètres utilisateur ou Mon profil, en fonction de l'option affichée.
    • Sur la page Paramètres d'utilisateur, sous Ressources, cliquez sur Clés d'API.
    • Cliquez sur Ajouter une clé publique.
    • Sélectionnez Coller des clés publiques.
    • Collez la valeur de l'étape précédente, y compris les lignes contenant BEGIN PUBLIC KEY et END PUBLIC KEY
    • Cliquez sur Ajouter.
    Vous avez maintenant configuré l'interface de ligne de commande pour vous connecter à votre location avec votre compte utilisateur.
  4. Testez l'installation : 
    oci os ns get

    Si tout est configuré correctement, l'espace de noms s'affiche.

  5. Désactivez l'environnement virtuel : 
    deactivate

    Le préfixe (cli-app) de votre environnement n'apparaît plus.

    Remarque

    • Lorsque vous souhaitez utiliser l'interface de ligne de commande, activez-la avec : workon cli-app
    • Si vous modifiez des noms de projet, workon désactive l'environnement dans lequel vous vous trouvez. Vous pouvez ainsi basculer rapidement entre les environnements.
Configuration du client Fn

Pour effectuer le développement de fonction sur votre ordinateur local, vous devez installer le client Fn. Fn vous permet de créer des fonctions, de créer des applications et de déployer des fonctions vers OCI Registry.

  1. Installez le client Fn.

    Le client Fn permet de créer, de gérer et de déployer des fonctions Oracle. Pour installer le client, procédez comme suit :

    Option de ligne de commande pour Linux, pour macOS et pour la mise à jour 2004 de Windows 10 (WSL 2.0) :

    Saisissez ce qui suit :

    curl -LSs https://raw.githubusercontent.com/fnproject/cli/master/install | sh
    Remarque

    Réexécutez régulièrement la commande d'installation pour effectuer la mise à niveau vers la dernière version de Fn.

    MacOS avec Homebrew :

    Saisissez ce qui suit :

    brew install fn
    Remarque

    Fn est mis à jour dans le cadre des mises à niveau normales de Homebrew : brew upgrade.
  2. Testez l'installation Fn.

    Saisissez : fn version

    La commande renvoie un texte semblable à ce qui suit :

    Client version is latest version: 0.6.3
Server version: ?
    Remarque

    La réponse indique que vous avez installé la version actuelle et que le serveur du projet Fn n'est pas en cours d'exécution sur votre ordinateur local.

4. Préparation d'OCI Registry pour Functions

A présent, connectez Docker à OCI Registry (OCIR).

Connexion de Docker à OCIR
  1. Récupérez les informations collectées précédemment.
  2. Ouvrez une fenêtre de terminal.
  3. Connectez-vous à OCIR : 
    docker login <region-key>.ocir.io

    Vous êtes invité à saisir le nom et le mot de passe de connexion.

    • Nom utilisateur : <tenancy-name>/<user-name>
    • Mot de passe : <auth-token>

Vous avez connecté votre instance à OCIR.

5. Configuration de Functions

Pour utiliser Oracle Functions, vous devez configurer le contexte d'application Fn. Le contexte stocke les valeurs nécessaires à la connexion au service Oracle Functions.

Configuration du contexte Fn

Utilisez les informations collectées précédemment pour renseigner les valeurs de configuration.

  1. Ouvrez une instance de terminal.
  2. Obtenez la liste des contextes Fn.

    fn list context

    Le contexte default est sélectionné.

  3. Créez un contexte Fn pour Oracle Functions. <identificateur-de-région> est un nom approprié pour le contexte.

    Exemple de commande : fn create context <identificateur-de-région> --provider oracle

    Exemple : fn create context us-phoenix-1 --provider oracle

  4. Utilisez le contexte que vous avez créé.

    Exemple : fn use context us-phoenix-1

  5. Définissez le compartiment pour Oracle Functions.

    Exemple : fn update context oracle.compartment-id ocid1.compartment.oc1..aaaaaa...

  6. Définissez l'URL d'API pour la région Oracle Functions.

    Exemple : fn update context api-url https://functions.us-phoenix-1.oci.oraclecloud.com

    Remarque

    Vous pouvez trouver les adresses d'API ici : Adresses d'API Oracle Functions
  7. Définissez l'URL du référentiel de registre.

    Exemple de commande : fn update context registry <clé-de-région>.ocir.io/<espace-de-noms-de-location>/<nom-de-référentiel>

    Exemple : fn update context registry phx.ocir.io/my-tenancy/myproject/repo

Remarque

Si vous utilisez plusieurs profils pour l'interface de ligne de commande, vous devez définir une valeur oracle.profile.

Exemple : fn update context oracle.profile <nom-de-profil>

Vous avez configuré Fn pour la connexion au service Oracle Functions.

Remarque

Affichage/Modification du contexte

Les fichiers de contexte Fn se trouvent dans le répertoire ~/.fn/contexts. Chaque contexte est stocké dans un fichier .yaml. Par exemple, le fichier us-phoenix-1.yaml peut ressembler à ce qui suit :

api-url: https://functions.us-phoenix-1.oci.oraclecloud.com
oracle.compartment-id: ocid1.compartment.oc1..aaaaaaa...
provider: oracle
registry: phx.ocir.io/my-tenancy/myproject/repo

Si nécessaire, vous pouvez modifier le fichier directement à l'aide d'un éditeur.

Pour obtenir une explication détaillée de chaque étape, reportez-vous à la documentation sur le démarrage rapide d'Oracle Functions dans un environnement de développement local.

6. Création et déploiement d'une fonction

Une fois la configuration terminée, créez et déployez une fonction.

Création d'une application

Une application est le conteneur de stockage principal des fonctions. Chaque fonction doit avoir une application pour le déploiement. Pour créer une application, suivez les étapes ci-après.

  1. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Fonctions, cliquez sur Applications.
  2. Cliquez sur Créer une application.

    Renseignez les données du formulaire.

    • Nom : <your-app-name>
    • VCN : <your-VCN>
    • Sous-réseaux : <votre-sous-réseau-public> ou <votre-sous-réseau-privé>
    Remarque

    Vous pouvez utiliser un sous-réseau public ou privé. Sélectionnez l'une des deux options.
  3. Cliquez sur Créer.

L'application est créée.

Création et déploiement de la fonction

Sélectionnez l'un des langages suivants pour créer et déployer une fonction. Si vous le souhaitez, vous pouvez utiliser les trois langages.

Création et déploiement d'une fonction Java

Une fois l'application créée, déployez une fonction Java. Pour créer une fonction "Hello World" Java, procédez comme suit.

Remarque

Vérifiez que Java 8+ est installé pour effectuer ces étapes.
  1. Ouvrez un terminal.
  2. Créez un répertoire pour stocker vos fonctions. Changez ensuite de répertoire pour utiliser celui que vous venez de créer. 
    mkdir my-dir-name
cd my-dir-name
  3. Créez une fonction "Hello World" Java avec Fn. 
    fn init --runtime java my-func-name

    Cette commande crée un répertoire nommé my-func-name contenant plusieurs fichiers.

    • func.yaml : fichier de configuration de la fonction.
    • pom.xml : fichier de build Maven.
    • src/main/java/com/example/fn/HelloFunction.java : fichier de la fonction réelle.
  4. Changez de répertoire pour passer à celui susmentionné.
  5. Déployez la fonction. 
    fn -v deploy --app your-app-name

    Plusieurs messages sont affichés lorsque les images Docker sont créées, propagées vers OCIR et finalement déployées vers Oracle Functions.

  6. Appelez la fonction. 
    fn invoke your-app-name my-func-name

    Valeur renvoyée : Hello, world!

  7. Appelez la fonction avec un paramètre. 
    echo -n "Bob" | fn invoke your-app-name my-func-name

    Valeur renvoyée : Hello, Bob!

  8. Si vous souhaitez vous connecter à la fonction à partir d'Internet, vous devez obtenir l'adresse d'appel de la fonction. Pour rechercher l'adresse d'appel, utilisez la commande inspect. 
    fn inspect function your-app-name my-func-name
  9. Examinez les résultats de la commande inspect. L'URL de l'adresse d'appel est incluse dans la section annotations des données JSON renvoyées. 
    {
    "annotations": {
        "fnproject.io/fn/invokeEndpoint": "https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke",
        "oracle.com/oci/compartmentId": "ocid1.compartment.oc1..aaaaaaaa...",
        "__comment":"Remaining output left out for brevity",
  10. Utilisez l'URL renvoyée par inspect pour appeler la fonction. Etant donné que les fonctions exigent la signature numérique des demandes, la commande oci raw-request est utilisée pour cet exemple. 
    oci raw-request --http-method POST --request-body "" --target-uri https://https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke

    La commande renvoie ce qui suit :

    {
    "data": "Hello, world!",
    "headers": {
        "Content-Length": "13",
        "Content-Type": "text/plain",
        "Date": "Tue, 20 Oct 2020 00:53:08 GMT",
        "Fn-Call-Id": "11111111111",
        "Fn-Fdk-Version": "fdk-java/1.0.111 (jvm=OpenJDK 64-Bit Server VM, jvmv=11.0.8)",
        "Opc-Request-Id": "1111111/11111"
    },
    "status": "200 OK"
}
    Remarque

    Vous pouvez vous connecter à une adresse Functions à l'aide d'outils tels que curl. Toutefois, pour des raisons de sécurité, le script est complexe. Vous pouvez alors utiliser la commande raw-request de l'interface de ligne de commande OCI. Reportez-vous à Appel de fonctions : envoi d'une demande signée à une fonction avec raw-request.

Vous avez déployé et testé une fonction Java.

Création et déploiement d'une fonction Python

Une fois l'application créée, déployez une fonction Python. Pour créer une fonction "Hello World" Python, procédez comme suit.

  1. Ouvrez un terminal.
  2. Créez un répertoire pour stocker vos fonctions. Changez ensuite de répertoire pour utiliser celui que vous venez de créer. 
    mkdir my-dir-name
cd my-dir-name
  3. Créez une fonction "Hello World" Python avec Fn. 
    fn init --runtime python my-func-name

    Cette commande crée un répertoire nommé my-func-name contenant plusieurs fichiers.

    • func.yaml : fichier de configuration de la fonction.
    • requirements.txt : liste des bibliothèques Python requises.
    • func.py : fichier de la fonction réelle.
  4. Changez de répertoire pour passer à celui susmentionné.
  5. Déployez la fonction. 
    fn -v deploy --app your-app-name

    Plusieurs messages sont affichés lorsque les images Docker sont créées, propagées vers OCIR et finalement déployées vers Oracle Functions.

  6. Appelez la fonction. 
    fn invoke your-app-name my-func-name

    Valeur renvoyée : {"message": "Hello World"}

  7. Appelez la fonction avec un paramètre. 
    echo -n '{"name":"Bob"}' | fn invoke your-app-name my-func-name

    Valeur renvoyée : {"message": "Hello Bob"}

  8. Si vous souhaitez vous connecter à la fonction à partir d'Internet, vous devez obtenir l'adresse d'appel de la fonction. Pour rechercher l'adresse d'appel, utilisez la commande inspect. 
    fn inspect function your-app-name my-func-name
  9. Examinez les résultats de la commande inspect. L'URL de l'adresse d'appel est incluse dans la section annotations des données JSON renvoyées. 
    {
    "annotations": {
        "fnproject.io/fn/invokeEndpoint": "https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke",
        "oracle.com/oci/compartmentId": "ocid1.compartment.oc1..aaaaaaaa...",
        "__comment":"Remaining output left out for brevity",
  10. Utilisez l'URL renvoyée par inspect pour appeler la fonction. Etant donné que les fonctions exigent la signature numérique des demandes, la commande oci raw-request est utilisée pour cet exemple. 
    oci raw-request --http-method POST --request-body "" --target-uri https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke

    La commande renvoie ce qui suit :

    {
    "data": "Hello World",
    "headers": {
        "Content-Length": "24",
        "Content-Type": "application/json",
        "Date": "Tue, 20 Oct 2020 00:53:08 GMT",
        "Fn-Call-Id": "11111111111",
        "Fn-Fdk-Version": "fdk-python/0.1.18",
        "Opc-Request-Id": "1111111/11111"
    },
    "status": "200 OK"
}
    Remarque

    Vous pouvez vous connecter à une adresse Functions à l'aide d'outils tels que curl. Toutefois, pour des raisons de sécurité, le script est complexe. Vous pouvez alors utiliser la commande raw-request de l'interface de ligne de commande OCI. Reportez-vous à Appel de fonctions : envoi d'une demande signée à une fonction avec raw-request.

Vous avez déployé et testé une fonction Python.

Création et déploiement d'une fonction Node

Une fois l'application créée, déployez une fonction Node. Pour créer une fonction "Hello World" Node, procédez comme suit.

Remarque

Vérifiez que Node.js 10+ est installé pour effectuer ces étapes.
  1. Ouvrez un terminal.
  2. Créez un répertoire pour stocker vos fonctions. Changez ensuite de répertoire pour utiliser celui que vous venez de créer. 
    mkdir my-dir-name
cd my-dir-name
  3. Créez une fonction "Hello World" Node avec Fn. 
    fn init --runtime node my-func-name

    Cette commande crée un répertoire nommé my-func-name contenant plusieurs fichiers.

    • func.yaml : fichier de configuration de la fonction.
    • package.json : fichier de build NPM.
    • func.js : fichier de la fonction réelle.
  4. Changez de répertoire pour passer à celui susmentionné.
  5. Déployez la fonction. 
    fn -v deploy --app your-app-name

    Plusieurs messages sont affichés lorsque les images Docker sont créées, propagées vers OCIR et finalement déployées vers Oracle Functions.

  6. Appelez la fonction. 
    fn invoke your-app-name my-func-name

    Valeur renvoyée : {"message":"Hello World"}

  7. Appelez la fonction avec un paramètre. 
    echo -n '{"name":"Bob"}' | fn invoke your-app-name my-func-name

    Valeur renvoyée : {"message":"Hello Bob"}

  8. Si vous souhaitez vous connecter à la fonction à partir d'Internet, vous devez obtenir l'adresse d'appel de la fonction. Pour rechercher l'adresse d'appel, utilisez la commande inspect. 
    fn inspect function your-app-name my-func-name
  9. Examinez les résultats de la commande inspect. L'URL de l'adresse d'appel est incluse dans la section annotations des données JSON renvoyées. 
    {
    "annotations": {
        "fnproject.io/fn/invokeEndpoint": "https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke",
        "oracle.com/oci/compartmentId": "ocid1.compartment.oc1..aaaaaaaa...",
        "__comment":"Remaining output left out for brevity",
  10. Utilisez l'URL renvoyée par inspect pour appeler la fonction. Etant donné que les fonctions exigent la signature numérique des demandes, la commande oci raw-request est utilisée pour cet exemple. 
    oci raw-request --http-method POST --request-body "" --target-uri https://https://aaaaaaaaa.us-ashburn-1.functions.oci.oraclecloud.com/1111111/functions/ocid1.fnfunc.oc1.iad.aaaaaaaaa.../actions/invoke

    La commande renvoie ce qui suit :

    {
    "data": "Hello World",
    "headers": {
        "Content-Length": "23",
        "Content-Type": "application/json",
        "Date": "Tue, 22 Oct 2020 00:53:08 GMT",
        "Fn-Call-Id": "11111111111",
        "Fn-Fdk-Version": "fdk-node/0.1.18 (njsv=v11.15.0)",
        "Opc-Request-Id": "1111111/11111"
    },
    "status": "200 OK"
}
    Remarque

    Vous pouvez vous connecter à une adresse Functions à l'aide d'outils tels que curl. Toutefois, pour des raisons de sécurité, le script est complexe. Vous pouvez alors utiliser la commande raw-request de l'interface de ligne de commande OCI. Reportez-vous à Appel de fonctions : envoi d'une demande signée à une fonction avec raw-request.

Vous avez déployé et testé une fonction Node.

7. Vérification des informations sur la fonction

Une fois les fonctions exécutées, leurs informations sont disponibles dans la console OCI.

Affichage des images de fonction dans OCIR

Lorsque vous effectuez un déploiement, la fonction est téléchargée et stockée dans OCIR. Vous pouvez accéder à OCIR et examiner les images de la fonction.

  1. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Conteneurs et artefacts, cliquez sur Registre du conteneur.
  2. Recherchez <nom-du-projet-de-référentiel>.
  3. Sous le nom du projet, une entrée s'affiche pour chaque fonction déployée.
  4. Cliquez sur le lien de chaque image dont vous souhaitez afficher les informations.
Affichage des informations d'exécution de fonction

Après avoir exécuté une fonction, vous pouvez afficher les mesures correspondantes.

  1. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Fonctions, cliquez sur Applications.

    Vos applications sont répertoriées sur la page.

  2. Cliquez sur le lien de l'application que vous avez créée.
  3. Cliquez sur le lien de la fonction à examiner.

    Les informations de mesure relatives à la fonction sont affichées.

Activation et affichage des informations de journalisation

Afin d'activer la journalisation pour une application, réalisez les étapes suivantes.

  1. Ouvrez le menu de navigation et cliquez sur Services de développeur. Sous Fonctions, cliquez sur Applications.
  2. Cliquez sur le lien de l'application que vous avez créée.
  3. Dans la partie gauche de la page de l'application, cliquez sur le lien Journaux.
  4. Cliquez sur Désactivé afin d'activer la journalisation pour l'application.
  5. La boîte de dialogue Activer le journal s'affiche. Renseignez les informations suivantes :
    • Compartiment : <nom-du-compartiment>
    • Groupe de journaux : utilisez la valeur par défaut Créer automatiquement un groupe de journaux par défaut
    • Nom de journal : <take-default>
    • Conservation de journal : <take-default>
    • Cliquez sur Activer le journal.

      Patientez quelques instants le temps de créer le journal.

Pour afficher le journal, cliquez sur le lien du nom de journal créé lors des étapes précédentes.