Remarques :

Publication d'un message dans OCI Notifications, déclenchement d'une fonction et création d'un fichier dans le bucket OCI Object Storage

Introduction

Vous pouvez configurer un service de publication/abonnement tel qu'Oracle Cloud Infrastructure (OCI) Notifications qui propage des messages vers des adresses capables d'alerter et d'agir via un abonnement configuré. Il ne prend pas uniquement en charge l'utilisation d'Oracle Cloud Infrastructure Monitoring ou d'OCI Connector Hub les cas, mais aussi les événements peuvent être générés à partir des applications client, des messages d'API qui doivent représenter une action immédiate à exécuter lorsque l'application envoie un message lorsqu'un événement déclenche OCI Notifications.

L'architecture peut être plus ou moins complexe, mais pour ce cas d'utilisation, le client effectue une demande HTTP POST, en envoyant dans le corps un JSON qui a certains attributs à Créez un fichier, tel que le nom du fichier, le nom du bucket dans lequel créer le fichier dans OCI Object Storage et le message qui sera à l'intérieur du fichier.

Ensuite, l'application REST d'API déployée dans Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) et développée dans Node.js obtient le JSON à partir du corps de la demande et, dans cette application, les bibliothèques OCI sont utilisées pour publier un message dans OCI Notifications dont une fonction Node.js est déjà abonnée et développée pour créer le fichier texte dans un bucket spécifique dans OCI Object Storage avec les paramètres JSON envoyés.

Architecture OCI

Architecture OCI

Architecture de cas d'emploi

Architecture de cas d'emploi

Dans ce tutoriel, nous allons commencer la configuration à partir du dernier service jusqu'à atteindre le premier dans Oracle Cloud Infrastructure (OCI) :

Objectifs

Prérequis

Tâche 1 : création d'un bucket dans OCI Object Storage

  1. Connectez-vous à la console OCI, accédez à Stockage, Object Storage et Archive Storage, Buckets et sélectionnez le compartiment de votre préférence.

  2. Cliquez sur Créer un bucket et entrez les informations suivantes.

    • Nom du compartiment : entrez le nom du compartiment. Par exemple, data ou un autre nom.
    • Niveau de stockage par défaut : pour ce tutoriel, sélectionnez Standard.
    • Cryptage : sélectionnez Crypter à l'aide des clés gérées Oracle.
    • Journalisation des ressources : sélectionnez Journalisation des ressources activée pour pouvoir observer ce qui se passe dans le bucket.

    Créer un bucket

Tâche 2 : configurer et créer des fonctions OCI

  1. Accédez à la console OCI, accédez à Services de développeur, à Fonctions, à Applications et sélectionnez Compartiment.

  2. Cliquez sur Créer une application et entrez les informations suivantes.

    • Nom : entrez le nom de l'application de fonction.
    • VCN : sélectionnez le VCN créé au cours des prérequis.
    • Sous-réseaux : sélectionnez le sous-réseau créé lors des prérequis. Dans ce tutoriel, nous avons configuré un sous-réseau public.
    • Forme : sélectionnez la forme associée au processeur pris en charge par cette application. Pour ce tutoriel, il s'agit de GENERIC_X86.

    Créer une application de fonction

  3. Activez les journaux pour suivre l'exécution et voir les erreurs de l'application OCI Functions. Ainsi, dans les détails de l'application de fonction, sous Ressources, cliquez sur Journaux et sélectionnez Activer le journal pour configurer le compartiment, le groupe de journaux, le nom du journal et l'heure de la conservation de journal.

    Activer l'application de fonction des journaux

Tâche 3 : configurer, développer et propager des fonctions OCI à l'aide de FDK Node.js pour créer un fichier texte

Configurez, développez et propagez des fonctions OCI à l'aide de FDK Node.js pour créer un fichier texte dans un bucket spécifique à partir de paramètres JSON.

Remarque : configurez votre client, par exemple : Bureau, PC, ordinateur portable ou machine virtuelle, ainsi que le contexte de votre fonction dans laquelle vous allez travailler avec le projet Fn, car OCI Functions est optimisé par le moteur open source du projet Fn afin d'effectuer des opérations de création, de lecture, de mise à jour et de suppression sur OCI Functions.

Nous utiliserons une machine virtuelle Oracle Linux 8 (hôte admin) dans OCI comme indiqué dans l'architecture dans Introduction.

  1. Accédez à la console OCI, accédez à Services de développeur, à Fonctions, à Applications et cliquez sur l'application de fonction.

  2. Sous la section Ressources, cliquez sur Mise en route et sélectionnez Configuration locale pour utiliser une machine virtuelle Oracle Linux externe.

    Configuration locale

    Remarque : vous devez avoir installé les composants suivants.

    • OCI Command Line Interface (CLI).

    • Node.js dans Oracle Linux.

      sudo yum update
sudo yum install -y nodejs
node --version

      La version de Node.js doit être prise en charge par OCI FDK Functions.

      Version prise en charge dans OCI Functions - node.js

      Si la version n'est pas prise en charge, il est nécessaire d'exécuter les commandes suivantes.

      Par exemple :

      sudo yum module reset nodejs
sudo yum module enable nodejs:18
sudo yum module install nodejs

    • Interface de ligne de commande du projet Fn installée dans votre machine virtuelle. Pour plus d'informations, reportez-vous à la section Installing the Fn Project CLI.

  3. Créez votre projet dans le langage de programmation souhaité. Dans ce tutoriel, nous utiliserons Node.js. Pour créer un projet, exécutez la commande suivante.

    fn init --runtime node "Name_Of_Your_Project"

    Par exemple :

    fn init --runtime node app_mess_createFile_os_function

  4. Pour accéder au dossier du projet, exécutez la commande suivante.

    cd "Name_Of_Your_Project"/

    Par exemple :

    cd app_mess_createFile_os_function/

  5. Créez et mettez à jour un contexte spécifique pour notre compartiment et l'URL d'API Oracle Functions pour votre région indiquée dans Mise en route.

    fn create context "specific_context" --provider oracle

    fn use context "specific_context"

    fn update context "your_compartment_id"

    fn update context api-url "your_api_url"

    Par exemple :

    fn create context Developer_OCI --provider oracle

    fn use context Developer_OCI

    fn update context oracle.compartment-id ocid1.compartment.oc1..aaaaaaaa4ixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

    fn update context api-url https://functions.sa-vinhedo-1.oraclecloud.com

  6. Entrez le chemin du registre de conteneurs Oracle Cloud Infrastructure vers lequel propager l'image d'application.

    Remarque : si vous ne disposez pas d'Oracle Cloud Infrastructure Container Registry, vous devez créer ce référentiel pour propager l'image de fonction.

    1. Accédez à Services de développeur, à Conteneurs et artefacts, à Container Registry et cliquez sur Créer un référentiel.

    2. Entrez les informations suivantes et cliquez sur Créer.

      • Créer dans le compartiment : sélectionnez votre compartiment,
      • Accès : sélectionnez Public.
      • nom du référentiel : entrez le nom du référentiel.

      Création d'Oracle Cloud Infrastructure Container Registry

    Une fois que vous êtes sûr qu'Oracle Cloud Infrastructure Container Registry a été créé, définissez le chemin de ce référentiel jusqu'à ce que le préfixe soit placé dans le contexte.

    fn update context registry "regionID.ocir.io/tenancy_namespace/[repo-name-prefix]"

    Par exemple :

    fn update context registry vcp.ocir.io/idccixxxxx/apigwrepo

  7. Connectez-vous à Oracle Cloud Infrastructure Container Registry.

    Remarque : pour vous connecter, créer, extraire et transmettre des images au référentiel, vous devez disposer des éléments suivants :

    Exécutez la commande suivante pour vous connecter à Oracle Cloud Infrastructure Container Registry.

    sudo docker login -u 'tenancy_namespace/username' regionID.ocir.io

    Password: xxxxxx

    Exemple (Dans cet exemple, le nom utilisateur est fédéré avec Oracle Identity Cloud Service et doit donc être inclus) :

    sudo docker login -u 'idccixxxxx/OracleIdentityCloudService/ivan.v.vasquez@oracle.com' vcp.ocir.io

    Password: xxxxxx

    Connexion

  8. Une fois que vous avez configuré OCI Functions, nous développerons le programme Node.js pour créer un fichier texte dans un bucket spécifique.

    Nous avons créé le projet fonctionnel dans la tâche 3.3, il crée les fichiers suivants dans le dossier du projet :

    • func.js (Dans ce fichier, nous écrivons la logique du projet node.js).
    • func.yaml (fichier de configuration de la fonction).
    • package.json (Ce fichier indique les dépendances Node.js requises pour la logique du projet).

    Dans ce projet, nous devrons ajouter les dépendances de kit SDK OCI Node.js suivantes : oci-objectstorage et oci-common. Exécutez la commande suivante pour installer les dépendances.

    npm install oci-common

    Ajout de dépendances oci-common

    npm install oci-objectstorage

    Ajout de Dependance oci-objectstorage

    Les dépendances ajoutées dans le fichier package.json sont visibles.

    Dépendances ajoutées

    Nous allons nous authentifier dans OCI à partir du code à l'aide du fichier de configuration, comme pour le processus de configuration de l'interface de ligne de commande OCI, où les clés et le fichier de configuration ont été placés dans le dossier du projet Fn.

    Dossier du projet de fonction

    Vous trouverez ci-dessous le code source Node.js et les détails de chaque fragment de code sont expliqués avec des commentaires.

    • func.js.

      //Dependencies are added
const fdk= require('@fnproject/fdk');
const os = require("oci-objectstorage");
const common = require("oci-common");

//method invoked when is triggered the function
fdk.handle(async function(input){
try{
    //declaration of constants such as tenancy namespace and region
    const namespace = 'idccixxxxx';
    const region = 'sa-vinhedo-1';
    //declaration of variables required such as bucket name, file name and text for create the file text in a specific bucket
    let bucketName = 'data';
    let objectName = 'empty.txt';
    let fileMessage = 'Empty!'

    //Getting json values from input variable
    if (input.objectName) {
        objectName = input.objectName;
    }

    if (input.bucketName){
        bucketName = input.bucketName;
    }

    if (input.fileMessage){
        fileMessage = input.fileMessage;
    }

    //Creation of Authentication, using Config File Authentication Object
    const configurationFilePath = "config";
    const configProfile = "DEFAULT";
    const provider = new common.ConfigFileAuthenticationDetailsProvider(
    configurationFilePath,
    configProfile
    );

    //Creation of Object Storage Client using authentication object
    const client = new os.ObjectStorageClient({authenticationDetailsProvider: provider});
    client.regionId = region;

    //The object to upload to the object store.
    const putObjectRequest = {
        namespaceName: namespace, //namespace of your object storage
        bucketName: bucketName,   //name of the bucket where the file will be placed
        objectName: objectName,   //name of the text file
        putObjectBody: generateStreamFromString(fileMessage) //The body that will be uploaded in the object stored
    };

    //Put the text file object in the object storage specified
    const response = await client.putObject(putObjectRequest);

    return {'message': 'Bucket Name: ' + bucketName+' - FileName: '+objectName+ ' \nMessage: '+fileMessage}
    }catch (error) {
    console.error('Error uploading to Object Storage:', error);
    }
})

//return ReadableStream object required by putObjectBody, using the string message that will write in the text file
function generateStreamFromString(data) {
let Readable = require("stream").Readable;
let stream = new Readable();
stream.push(data); // the string you want
stream.push(null);
return stream;
}

    Remarque : téléchargez le projet OCI Functions à l'adresse suivante : app_mess_createFile_os_function.zip.

  9. Le projet est créé. Assurez-vous de rester connecté à Oracle Cloud Infrastructure Container Registry. Nous allons créer et propager l'image dans Oracle Cloud Infrastructure Container Registry, et déployer cette fonction dans l'application OCI Functions.

    1. Accédez à la console OCI, accédez à Services de développeur, à Fonctions, à Applications et cliquez sur l'application de fonction.

      Sur notre ordinateur local, nous devons nous trouver dans le dossier de projet OCI Functions.

      fn deploy --app name_of_your_function_application

      Par exemple :

      fn deploy --app fn-demo-apgw

      Déployer la fonction dans Oracle Cloud Infrastructure Container Registry

    2. Pour valider le déploiement de l'image dans Oracle Cloud Infrastructure Container Registry, accédez à la console OCI et accédez à Services de développeur, à Conteneurs et artefacts et à Container Registry.

      Archiver l'image de console OCI propagée dans Oracle Cloud Infrastructure Container Registry

      Pour vérifier si la fonction est déployée dans l'application OCI Functions, accédez à la console OCI et accédez à Services de développeur, à Fonctions, à Applications, cliquez sur l'application de fonction et vérifiez que l'image y est référencée avec le chemin Oracle Cloud Infrastructure Container Registry.

      Archiver l'image de console OCI déployée dans OCI Functions

  10. Exécutez un test à partir de votre ordinateur local, la commande de projet Fn suivante simulant une entrée avec les paramètres fournis par un format JSON.

    echo -n '{"jsonVariable": "value"}' | fn invoke application_function_name function_name

    Par exemple :

    echo -n '{"objectName": "tutorialFileText.txt", "bucketName":"data", "fileMessage":"This an example message, for this tutorial in the text file"}' | fn invoke fn-demo-apgw app_mess_createfile_os_function

    Invocation de la fonction

    Pour consulter le fichier créé dans le bucket, accédez à Stockage, Object Storage et Archive Storage, Buckets, cliquez sur le bucket et vérifiez que le fichier est présent.

    Validation du regroupement

    Vérifier le fichier

Tâche 4 : création d'un sujet de notifications OCI et d'un abonnement associant des fonctions OCI en tant qu'adresse

  1. Créez et utilisez OCI Notifications. Lorsqu'un message est publié dans un sujet de ce service, il génère un déclencheur vers une adresse. Ce point de terminaison sera la fonction créée dans la tâche 3.

    Accédez à la console OCI, accédez à Services de développeur, à Intégration d'applications et à Notifications. Cliquez sur Créer une rubrique et saisissez le nom de cette rubrique.

    Création d'un sujet dans OCI Notifications

    Sujet créé dans OCI Notifications

  2. Pour créer un abonnement pour ce sujet, cliquez sur le sujet et sur Créer un abonnement. Dans ce tutoriel, nous allons sélectionner Functions en tant qu'adresse. Vous pouvez sélectionner une adresse telle que Courriel, Slack, SMS, PagerDuty ou URL HTTPS et sélectionner le compartiment de fonction, l'application Oracle Functions et la fonction.

    Création d'un abonnement

    Inscription créée

    Remarque : dans OCI Notifications, nous pouvons créer plusieurs abonnements avec une adresse différente si nécessaire.

  3. A partir d'OCI Notifications, nous pouvons publier un message au format JSON avec les variables requises similaires à ce que nous avons fait dans la tâche 3 pour OCI Functions.

    Accédez à la console OCI, accédez à Services de développeur, à Intégration d'applications et à Notifications. Cliquez sur le sujet et saisissez le message comme indiqué dans l'image suivante.

    Exécution de la notification OCI

    Pour effectuer une vérification dans votre bucket, accédez à Stockage, Object Storage et Archive Storage et Buckets. Cliquez sur votre bucket et vérifiez si le fichier est présent.

    Tester à partir de la notification OCI

    Consulter le fichier test créé à partir d'OCI Notification

Tâche 5 : création et configuration d'un cluster Kubernetes dans Oracle Cloud Infrastructure Container Engine for Kubernetes

Dans cette tâche, nous allons créer un cluster Kubernetes simple. Pour plus d'informations, reportez-vous à la section Creation of OKE Cluster.

  1. Accédez à la console OCI, accédez à Services de développeur, à Conteneurs et artefacts et cliquez sur Clusters Kubernetes (OKE).

  2. Sur la page Clusters, cliquez sur Créer un cluster.

  3. Il existe deux workflows pour créer le cluster. Cliquez sur Créer personnalisé et Soumettre.

    • Création rapide : cette opération est plus facile, plus rapide et déploie automatiquement tous les éléments requis par OKE pour son fonctionnement, tels que :

      • Virtual Cloud Network (VCN)
      • Passerelle Internet
      • Passerelle NAT
      • Passerelle de service
      • Cluster Kubernetes
      • Pool de noeuds et noeuds de processus actifs Kubernetes

    • Création personnalisée : pour les environnements d'entreprise, dans lesquels les clients disposent déjà de services, de réseaux et d'infrastructures, il est important de personnaliser le déploiement OKE, afin qu'il soit conforme à l'architecture client, aux ressources et qu'il respecte les meilleures pratiques.

      Dans ce tutoriel, nous sélectionnerons Création personnalisée pour conserver l'architecture illustrée ci-dessus.

    Options de création d'un cluster OKE

  4. Entrez le nom, le compartiment et la version de Kubernetes du cluster, puis cliquez sur Suivant.

    Créer un cluster

  5. Sur la page Configuration réseau, entrez les informations suivantes et cliquez sur Suivant.

    • Type de réseau : sélectionnez Réseau de pod natif VCN. Pour plus d'informations, reportez-vous à Réseau POD.
    • VCN : sélectionnez votre VCN.
    • Sous-réseaux : sélectionnez un sous-réseau public et un sous-réseau privé. Dans ce tutoriel, nous utilisons un sous-réseau public pour l'équilibreur de charge et un sous-réseau privé pour l'adresse d'API.

    Configuration réseau

  6. Sur la page Pools de noeuds, entrez les informations suivantes.

    • Nom : entrez le nom du pool de noeuds.
    • Compartiment : sélectionnez votre compartiment.
    • Type de noeud : sélectionnez Géré. Pour plus d'informations, reportez-vous à Comparaison entre les noeuds virtuels et les noeuds gérés.
    • Version : sélectionnez la version de Kubernetes.
    • Configuration de placement de noeud :
      • Domaine de disponibilité : configurez le domaine de disponibilité.
      • Sous-réseau de noeud de processus actif : définissez le sous-réseau privé pour les noeuds qui seront créés dans ce pool de noeuds.
      • Domaine de pannes : sélectionnez les domaines de pannes dans lesquels vous souhaitez distribuer les noeuds.
    • Forme et image : sélectionnez une forme et une image pour nos noeuds de processus actif.
      • Forme de noeud : sélectionnez VM.Standard.E3.Flex Shape (16GB RAM memory and 1 OCPU).
      • Image : sélectionnez l'image Oracle-Linux-8.9-2024.01.26-0-OKE-1.28.2-679.
    • Nombre de noeuds : entrez 1. Pour ce tutoriel, 1 suffit.
    • Volume d'initialisation : nous ne modifierons pas les paramètres du volume d'initialisation.
    • Communications de pod : sélectionnez un sous-réseau privé.

    Pools de noeuds 1

    Pools de noeuds 2

  7. Vérifiez la configuration du cluster Kubernetes et cliquez sur Créer un cluster.

    Remarque : avant de cliquer sur Créer un cluster, assurez-vous que toutes les règles de liste de sécurité entrante et sortante ont été configurées dans chaque sous-réseau OKE pour l'équilibreur de charge, l'adresse d'API et les noeuds de processus actif. Pour plus d'informations, reportez-vous à Configuration de ressources réseau pour la création et le déploiement de clusters.

    Vérifier OKE

    Pour vérifier le cluster Kubernetes, accédez à Services de développeur, à Conteneurs et artefacts et à Clusters Kubernetes (OKE).

    Cluster OKE créé

  8. Pour accéder au cluster Kubernetes, cliquez sur le nom du cluster Kubernetes et sur Accéder au cluster.

    Vous pouvez constater que l'accès à Cloud Shell est désactivé et que l'accès local est activé, car lorsque nous avons sélectionné le sous-réseau d'adresse d'API, nous avons choisi un sous-réseau privé, ce qui est plus sécurisé. La seule façon d'accéder au cluster Kubernetes est d'utiliser une machine locale. C'est donc exactement la configuration que nous utilisons dans ce tutoriel avec notre machine virtuelle Oracle Linux hôte d'administration. Sélectionnez Accès local.

    Accéder au cluster

    Remarque : nous devons avoir installé l'interface de ligne de commande OCI, Docker et kubectl. Pour plus d'informations, reportez-vous à la section Installing kubectl.

  9. Une fois l'hôte d'administration prêt, exécutez la commande suivante pour accéder au cluster Kubernetes à partir de votre ordinateur local.

    1. Vérifiez la version de l'interface de ligne de commande OCI.

      oci -v

    2. Créez le répertoire kubeconfig dans votre répertoire de base.

      mkdir -p $HOME/.kube

    3. Créez un fichier kubeconfig avec une adresse privée native VCN.

      oci ce cluster create-kubeconfig --cluster-id ocid1.cluster.oc1.sa-vinhedo-1.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx --file $HOME/.kube/config --region sa-vinhedo-1 --token-version 2.0.0  --kube-endpoint PRIVATE_ENDPOINT

    4. Définissez la variable d'environnement kubeconfig.

      export KUBECONFIG=$HOME/.kube/config

  10. Pour vérifier l'accès au cluster Kubernetes, exécutez les commandes kubectl.

    • Obtention des noeuds de processus actif OKE.

      kubectl get nodes

      Noeuds get kubectl

    • Obtenez les pods OKE.

      kubectl get pods -A

      kubectl : obtenir des pods

Tâche 6 : développement et déploiement d'une application REST d'API dans Node.js et publication d'un message dans OCI Notifications

Dans ce tutoriel, nous allons développer et déployer une application REST d'API dans Node.js pour obtenir le JSON à partir du corps de la demande HTTP Post et publier ce corps JSON en tant que message dans OCI Notifications.

Nous allons créer un projet Node.js, créer le projet, le propager vers Oracle Cloud Infrastructure Container Registry et le déployer dans OKE. Nous allons utiliser un hôte d'administration Oracle Linux existant configuré pour OCI Functions. Nous avons donc déjà installé Node.js et Docker.

  1. Exécutez les commandes suivantes pour créer un dossier avec le nom de notre projet dans le répertoire de base de l'ordinateur local et accédez au dossier du projet.

    mkdir api_rest_application_oke

    cd api_rest_application_oke

  2. Pour initialiser un projet, exécutez la commande suivante et configurez le fichier package.json comme indiqué dans l'image suivante.

    npm init

    Projet nodejs

  3. Avant de développer le code Node.js, nous devons installer les bibliothèques requises pour le projet.

    • L'application REST API doit fonctionner comme une application Web. Nous aurons donc besoin d'une bibliothèque express.

      npm install express

      Installation de la bibliothèque Express

    • Nous devrons obtenir le corps JSON à partir de la demande HTTP POST. Nous aurons donc besoin de la bibliothèque body-parser.

      npm install body-parser

      Installation de la bibliothèque d'analyseur de corps

    • L'application devra s'authentifier auprès d'OCI pour avoir accès à ses services. Nous aurons donc besoin de la bibliothèque oci-common.

      npm install oci-common

      Installation de la bibliothèque oci-common

    • Pour publier un message dans OCI Notifications provenant du corps de la demande, nous avons besoin de la bibliothèque oci-ons.

      npm install oci-ons

      Installation de la bibliothèque oci-ons

    Notre package.json possède les dépendances suivantes.

    Fichier package.json

  4. Une fois le projet Node.js configuré, nous pouvons créer notre code dans le fichier index.js. Voici le code source.

    Nous allons nous authentifier dans OCI à partir du code à l'aide du fichier de configuration, comme pour la configuration de l'interface de ligne de commande OCI. Dans les deux cas, les clés et le fichier de configuration sont placés dans le dossier de projet d'application REST d'API, comme indiqué dans l'image suivante.

    Fichier de configuration dans le projet Rest API

    • index.js.

      //Dependencies are added
const ons = require("oci-ons"); //oci notifications library
const common = require("oci-common"); //oci authentication library
const express = require('express'); //web application framework
const bodyParser = require('body-parser');//extract information from an incoming HTTP request



//invocation of express framework
const app = express();
//definition of port that We will be used to listen the requests from the client side
const port = 8080;


//Create a default authentication provider that uses the DEFAULT
const provider = new common.ConfigFileAuthenticationDetailsProvider(
                "config",
            "DEFAULT"
        );


//Use in the body HTTP POST request json format
app.use(bodyParser.json());
//creation of POST endpoint
app.post('/api/receive-json', (req, res) => {
    const jsonData = req.body;

        //If the Body is empty or not json format return error
        if (!jsonData) {
            return res.status(400).json({ error: 'Invalid JSON data in the request body' });
        }

        (async () => {
            try {

            // Create OCI Notifications Client with OCI Authentication Object
            const client = new ons.NotificationDataPlaneClient({ authenticationDetailsProvider: provider });

            // Create constant message object required for OCI Notifications
            const messageDetails = {
                title: "PUBLISH_MESSAGE", //Message Title
                body: JSON.stringify(jsonData) //Body Message
            };

            //Create publish Message Request in a specific topic in OCI Notifications
            const publishMessageRequest = ons.requests.PublishMessageRequest = {
                    topicId: "ocid1.onstopic.oc1.sa-vinhedo-1.amaaaaaan4xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
                messageDetails: messageDetails
            };



            //Publish Message sending Publish Message Request object previously created
            const publishMessageResponse = await client.publishMessage(publishMessageRequest);

            } catch (error) {
            //error log
            console.log("publishMessage Failed with error  " + error);
            }
        })();

    res.json({ success: true, message: 'JSON data received successfully' });
});

//listening for a specific port
app.listen(port, () => {
console.log(`Server is running at http://localhost:${port}`);
});

  5. Dans le même dossier, créez Dockerfile, ce qui nous permettra de créer une image de conteneur.

    FROM node:14
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 8080
CMD [ "node", "index.js" ]

  6. Créez et propagez l'image du projet dans le référentiel Docker local.

    docker build . -t apirestapp:latest

    Créer une image docker

    Vérifiez l'image dans le référentiel Docker local.

    docker images

    Vérifier les images docker

    Remarque :

    • Vous devez disposer d'Oracle Cloud Infrastructure Container Registry. Reportez-vous à la tâche 3.6.

      Création du référentiel d'applications OKE

    • Vous devez être connecté à Oracle Cloud Infrastructure Container Registry, car nous utilisons le même hôte d'administration de machine local que celui auquel nous devrions être connectés. Reportez-vous à la tâche 3.7.

  7. Nous pouvons baliser l'image d'application REST d'API dans Oracle Cloud Infrastructure Container Registry.

    docker tag apirestapp:latest vcp.ocir.io/idccixxxxx/oke_application/oke_apirest_application_repository:latest

    Vérifiez dans le référentiel Docker local.

    docker images

    Marquer l'application OKE

    Poussez l'image vers Oracle Cloud Infrastructure Container Registry.

    docker push vcp.ocir.io/idccixxxxx/oke_application/oke_apirest_application_repository:latest

    Propager l'application OKE

    Pour consulter l'application d'image OKE dans Oracle Cloud Infrastructure Container Registry, accédez à Services de développeur, à Conteneurs et artefacts et à Container Registry.

    Image dans le registre OKE Containe

  8. Une fois l'image dans Oracle Cloud Infrastructure Container Registry, nous pouvons accéder à notre hôte d'administration de machine virtuelle Oracle Linux local et déployer cette image dans OKE. Pour ce tutoriel, exécutez la commande suivante afin de créer l'espace de noms et la clé secrète pour OKE.

    1. Accédez au dossier du projet.

      cd api_rest_application_oke/

    2. Créez un espace de noms pour OKE.

      kubectl create namespace ns-tutorial

      Créer un oke d'espace de noms

    3. Vérifiez l'espace de noms.

      kubectl get namespace ns-tutorial

      Vérifier oke d'espace de noms

    4. Créez une clé secrète pour OKE.

      kubectl create secret -n ns-tutorial generic ocir --from-file=.dockerconfigjson=../.docker/config.json --type=kubernetes.io/dockerconfigjson

      Créer une clé secrète

    5. Vérifiez la clé secrète.

      kubectl get secrets -A

      Vérifier oke secret

  9. L'environnement OKE est déjà prêt. Déployez donc l'image d'application d'Oracle Cloud Infrastructure Container Registry vers OKE.

    Remarque : pour déployer l'image d'application, vous devez disposer d'un fichier manifeste. Dans ce tutoriel, le fichier yaml suivant est le fichier manifeste. Il est utilisé pour déployer l'application et créer le service entrant représenté dans un équilibreur de charge OCI qui écoute à l'aide du port 80.

    • apirest_application_manifest.yaml.

      apiVersion: apps/v1
kind: Deployment
metadata:
name: app-restapi
namespace: ns-tutorial
labels:
    app: app-restapi
spec:
replicas: 1
selector:
    matchLabels:
    app: app-restapi
template:
    metadata:
    labels:
        app: app-restapi
    spec:
    containers:
    - name: app-restapi
        image: vcp.ocir.io/idccixxxxx/oke_application/oke_apirest_application_repository:latest
        ports:
        - containerPort: 8080
    imagePullSecrets:
    - name: ocir

apiVersion: v1
kind: Service
metadata:
name: svc-restapp
namespace: ns-tutorial
spec:
selector:
    app: app-restapi
ports:
    - port: 80
    targetPort: 8080
type: LoadBalancer

    • Exécutez la commande kubectl dans le dossier où vous avez enregistré le fichier manifeste.

      kubectl apply -f apirest_application_manifest.yaml

      Maintenant, l'application est déployée et le service d'équilibreur de charge entrant est créé dans OKE,

      Appliquer le manifeste dans OKE

    • Pour valider le pod et le service créés dans OKE, exécutez la commande suivante.

      kubectl get pods -A

      OKE PODS

      kubectl get svc -A

      Services OKE

    Remarque : téléchargez le projet d'application REST d'API à l'adresse suivante : api_rest_application_oke.zip.

Tâche 7 : demander HTTP POST avec corps JSON vers l'URL affichée dans l'équilibreur de charge de l'application REST d'API

Dans cette tâche, nous allons effectuer une demande HTTP POST avec le corps de message JSON du client Postman qui contient les données de base pour créer un fichier dans un bucket. Cette demande sera envoyée à l'application REST d'API dans OKE et la propagation du message dans la rubrique Notifications OCI déclenchera une fonction avec la logique permettant de créer un fichier texte dans un bucket spécifique, comme illustré dans l'architecture dans Introduction.

  1. Pour installer Postman, reportez-vous à la section Postman Installation.

  2. Ouvrez l'application Postman.

    1. Dans le menu latéral, cliquez sur Fichier et sélectionnez Nouveau.

      Menu Postman

    2. Sélectionnez HTTP.

      Option HTTP

    3. Entrez l'URL affichée par l'application REST d'API déployée dans OKE : http://"IP ADDRESS LOAD BALANCER"/api/receive-json et sélectionnez la méthode POST. Dans la balise Corps, sélectionnez brut et entrez le message JSON dans le champ vide.

      Demande de poste

  3. Cliquez sur Envoyer pour envoyer la demande.

    Postman de la demande de réponse

    Pour vérifier le fichier créé dans le bucket spécifique dans OCI Object Storage, accédez à Stockage, Object Storage et Archive Storage, Buckets et cliquez sur le bucket.

    Dernier fichier créé dans un bucket spécifique dans ce tutoriel

    Dernier fichier texte

Dans ce tutoriel, vous avez utilisé OCI Notifications avec un nouveau cas d'utilisation, en intégrant plusieurs services tels que les API, le kit SDK OCI, les applications Kubernetes déployées dans OKE, OCI Functions et OCI Object Storage.

Remerciements

Ressources de formation supplémentaires

Parcourez d'autres ateliers sur docs.oracle.com/learn ou accédez à davantage de contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, rendez-vous sur education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.