Note :

Ce tutoriel nécessite l'accès à Oracle Cloud. Pour vous inscrire à un compte gratuit, voir Introduction à l' niveau gratuit d'Oracle Cloud Infrastructure.
Il utilise des exemples de valeurs pour les données d'identification, la location et les compartiments Oracle Cloud Infrastructure. À la fin de votre laboratoire, remplacez ces valeurs par celles propres à votre environnement en nuage.

Publier un message dans le service d'avis pour OCI, déclencher une fonction et créer un fichier dans le seau de stockage d'objets pour OCI

Présentation

Vous pouvez configurer un service d'abonnement de publication, tel qu'un service d'avis pour Oracle Cloud Infrastructure (OCI), qui pousse des messages vers des points d'extrémité pouvant être alertés, effectuer une action au moyen d'un abonnement configuré; non seulement la prise en charge d'Oracle Cloud Infrastructure Monitoring ou de l'utilisation du centre de connecteurs OCI cas, mais aussi les événements peuvent être générés à partir des applications clients, 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 des avis OCI.

L'architecture peut être plus ou moins complexe, mais pour ce cas d'utilisation, le client effectue une demande HTTP POST, envoyant dans le corps un JSON qui a certains attributs à créer un fichier, tel que le nom du fichier, le nom du seau dans lequel vous voulez créer le fichier dans le service de stockage d'objets OCI et le message qui sera dans le 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 le service d'avis OCI auquel une fonction Node.js est déjà abonnée et développée pour créer le fichier texte dans un seau spécifique du service de stockage d'objets OCI avec les paramètres JSON envoyés.

Architecture OCI

Architecture OCI

Architecture de cas d'utilisation

Architecture de cas d'utilisation

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

Service de stockage d'objets OCI
Service des fonctions pour OCI
Avis OCI
Service Container Engine pour Kubernetes pour Oracle Cloud Infrastructure

Objectifs

Créez un nouveau seau de stockage d'objets pour OCI.
Configurez et créez le service des fonctions pour OCI.
Configurez, développez et poussez le service des fonctions pour OCI à l'aide de la trousse SDK Node.js pour créer un nouveau fichier texte dans un seau spécifique à partir de paramètres JSON.
Créez un nouveau sujet dans le service d'avis pour OCI et créez un abonnement associant un service des fonctions pour OCI en tant que point d'extrémité.
Créez et configurez une grappe Kubernetes dans OKE.
Développez et déployez 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 les avis OCI.
Demandez une demande HTTP POST avec un corps JSON à l'URL exposée dans l'équilibreur de charge de l'application REST d'API.

Préalables

Accès à un locataire OCI. Pour créer un compte Oracle Cloud gratuit, voir Créer un compte Oracle Cloud gratuit.
Installez l'interface de ligne de commande d'OCI. Pour plus d'informations, voir Installation de l'interface de ligne de commande OCI.
Créez un VCN avec des sous-réseaux publics et privés. Pour plus d'informations, voir Création d'un VCN et Création d'un sous-réseau.
Créer une table de routage pour le trafic d'accès à Internet à l'aide de la passerelle Internet. Pour plus d'informations, voir Tables de routage de VCN et Passerelle Internet.
Créez un compartiment dans lequel vous pouvez regrouper vos services OCI. Pour plus d'informations, voir Création d'un compartiment.

Tâche 1 : Créer un seau dans le service de stockage d'objets pour OCI

Connectez-vous à la console OCI, naviguez jusqu'à Stockage, Stockage d'objets et stockage d'archives, Seaux et sélectionnez le compartiment de vos préférences.
Cliquez sur Créer un seau et entrez les informations suivantes.
- Nom du seau : Entrez le nom du seau. Par exemple, data ou un autre nom.
- Niveau de stockage par défaut : Pour ce tutoriel, sélectionnez Standard.
- Chiffrement : Sélectionnez Chiffrer à l'aide des clés gérées par Oracle.
- Journalisation des ressources : Sélectionnez Journalisation des ressources activée pour avoir une observabilité sur ce qui se passe dans le seau.

Tâche 2 : Configurer et créer un service des fonctions pour OCI

Allez à la console OCI, naviguez jusqu'à Services de développement, Fonctions, Applications et sélectionnez Compartiment.
Cliquez sur Créer une application et entrez les informations suivantes.
- Nom : Entrez le nom de votre application fonctionnelle.
- VCN : Sélectionnez le VCN créé dans les conditions requises.
- Sous-réseaux : Sélectionnez le sous-réseau créé dans les préalables. 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.
Activez les journaux pour suivre l'exécution et voir les erreurs de l'application du service des fonctions pour OCI. 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 des journaux.

Tâche 3 : Configurer, développer et pousser le service des fonctions pour OCI à l'aide de la trousse FDK Node.js pour créer un nouveau fichier texte

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

Note : Configurez votre client tel que : Bureau, PC, ordinateur portable ou machine virtuelle (MV) et le contexte de votre fonction dans laquelle vous travaillerez avec Fn Project, car le service des fonctions pour OCI est alimenté par le moteur à code source libre Fn Project afin d'effectuer des opérations de création, de lecture, de mise à jour et de suppression sur le service des fonctions pour OCI.

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

Allez à la console OCI, naviguez jusqu'à Services de développement, Fonctions, Applications et cliquez sur votre application de fonction.
Sous la section Ressources, cliquez sur Démarrage et sélectionnez Configuration locale pour utiliser une machine virtuelle Oracle Linux externe.
Note : Vous devez avoir installé les composants suivants.
- Interface de ligne de commande (CLI). OCI
- 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 le service des fonctions FDK pour OCI.
  
  Si la version n'est pas prise en charge, il est nécessaire d'exécuter les commandes suivantes.
  
  Exemple :
  sudo yum module reset nodejs sudo yum module enable nodejs:18 sudo yum module install nodejs
- L'interface de ligne de commande Fn Project est installée dans votre machine virtuelle. Pour plus d'informations, voir Installation de l'interface de ligne de commande Fn Project.
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"
```
Exemple :
```
fn init --runtime node app_mess_createFile_os_function
```
Pour accéder au dossier de projet, exécutez la commande suivante.
```
cd "Name_Of_Your_Project"/
```
Exemple :
```
cd app_mess_createFile_os_function/
```

Créez et mettez à jour un contexte spécifique pour notre compartiment et l'URL de l'API Oracle Functions pour votre région spécifiée dans Introduction.

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"

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

Entrez le chemin du registre de conteneurs Oracle Cloud Infrastructure dans lequel l'image d'application sera poussée.
Note : Si vous ne disposez pas du registre de conteneurs Oracle Cloud Infrastructure, vous devez créer ce référentiel pour pousser l'image de la fonction.
1. Allez à Services de développement, Conteneurs et artefacts, Registre de conteneurs 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 le compartiment,
  - Accès : Sélectionnez Public.
  - Nom du référentiel : Entrez le nom du référentiel.
Une fois que vous êtes sûr de créer le registre de conteneurs pour Oracle Cloud Infrastructure, définissez le chemin de ce référentiel jusqu'au préfixe dans le contexte.
```
fn update context registry "regionID.ocir.io/tenancy_namespace/[repo-name-prefix]"
```
Exemple :
```
fn update context registry vcp.ocir.io/idccixxxxx/apigwrepo
```
Connectez-vous au service de registre de conteneurs d'Oracle Cloud Infrastructure.
Note : Pour vous connecter, créer, extraire et pousser des images dans le référentiel, vous devez disposer des éléments suivants :
- Docker installé. Pour plus d'informations, voir Comment installer Docker sur Oracle Linux 8/7.
- Nom d'utilisateur et jeton d'authentification Oracle Cloud Infrastructure créés. Pour plus d'informations, voir Obtention d'un jeton d'authentification
Exécutez la commande suivante pour vous connecter au service de registre de conteneurs pour Oracle Cloud Infrastructure.
```
sudo docker login -u 'tenancy_namespace/username' regionID.ocir.io
```
```
Password: xxxxxx
```
Exemple (Dans cet exemple, le nom d'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
```

Une fois que vous avez configuré le service des fonctions pour OCI, nous développerons le programme Node.js pour créer un fichier texte dans un seau spécifique.

Nous avons créé le projet de fonction dans la tâche 3.3, il crée les fichiers suivants dans le dossier de 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 spécifie les dépendances Node.js requises pour la logique du projet).

Dans ce projet, nous devrons ajouter les dépendances de trousse SDK pour 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épendance oci-common

npm install oci-objectstorage

Ajout de la dépendance oci-objectstorage

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

Dépendances ajoutées

Nous allons nous authentifier dans OCI à partir du code à l'aide du fichier de configuration, comme lors de la 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 Fn Project.

Dossier de projet de fonction

Ce qui suit est 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;
}

Note : Téléchargez le projet du service des fonctions pour OCI à partir d'ici : app_mess_createFile_os_function.zip.

Le projet est créé, assurez-vous de rester connecté au registre de conteneurs Oracle Cloud Infrastructure. Nous allons créer et pousser l'image dans le registre de conteneurs d'Oracle Cloud Infrastructure et déployer cette fonction dans l'application du service des fonctions pour OCI.
1. Allez à la console OCI, naviguez jusqu'à Services de développement, Fonctions, Applications et cliquez sur votre application de fonction.
  
  Dans notre machine locale, nous devons être dans le dossier de projet du service des fonctions pour OCI.
```
fn deploy --app name_of_your_function_application
```
  Exemple :
```
fn deploy --app fn-demo-apgw
```
2. Pour valider que l'image a été déployée dans le registre de conteneurs d'Oracle Cloud Infrastructure, allez à la console OCI et naviguez jusqu'aux services de développement, conteneurs et artefacts et registre de conteneurs.
  
  Pour vérifier si la fonction est déployée dans l'application du service des fonctions pour OCI, allez à la console OCI et naviguez jusqu'à Services de développement, Fonctions, Applications, cliquez sur votre application de fonction et vérifiez que l'image y est référencée avec le chemin du registre de conteneurs Oracle Cloud Infrastructure.
Exécutez un test à partir de votre machine locale, exécutez la commande Fn Project 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
```
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
```
Pour vérifier le fichier créé dans le seau, allez à Stockage, Stockage d'objets et stockage d'archives, Seaux et cliquez sur votre seau et vérifiez que le fichier est présent.

Tâche 4 : Créer un nouveau sujet d'avis OCI et un abonnement associant un service des fonctions pour OCI en tant que point d'extrémité

Créer et utiliser des avis OCI. Lorsqu'un message est publié dans un sujet au sein de ce service, il génère un déclencheur vers un point d'extrémité. Ce point d'extrémité sera la fonction créée dans la tâche 3.

Allez à la console OCI, naviguez jusqu'à Services de développement, Intégration d'applications et Avis. Cliquez sur Créer un sujet et entrez le nom de ce sujet.
Pour créer un abonnement pour ce sujet, cliquez sur votre sujet et sur Créer un abonnement. Dans ce tutoriel, nous sélectionnerons Functions comme point d'extrémité. Vous pouvez sélectionner un point d'extrémité, par exemple Courriel, Slack, SMS, PagerDuty ou URL HTTPS, et sélectionner le compartiment de fonctions, l'application Oracle Functions et la fonction.

Note : Dans le service d'avis pour OCI, nous pouvons créer plusieurs abonnements avec un point d'extrémité différent, si nécessaire.
À partir des avis OCI, nous pouvons publier un message au format JSON avec les variables requises similaires à celles de la tâche 3 pour le service des fonctions pour OCI.

Allez à la console OCI, naviguez jusqu'à Services de développement, Intégration d'applications et Avis. Cliquez sur votre sujet et entrez le message comme indiqué dans l'image suivante.

Pour une vérification dans votre seau, allez à Stockage, Stockage d'objets et stockage d'archives et Seaux. Cliquez sur votre seau et vérifiez si le fichier est présent.

Tâche 5 : Créer et configurer une grappe Kubernetes dans Oracle Cloud Infrastructure Container Engine for Kubernetes

Dans cette tâche, nous allons créer une grappe Kubernetes simple. Pour plus d'informations, voir Création d'une grappe OKE.

Allez à la console OCI, naviguez jusqu'à Services de développement, Conteneurs et artefacts et cliquez sur Grappes Kubernetes (OKE).
Dans la page Grappes, cliquez sur Créer une grappe.
Nous avons deux flux de travail pour créer la grappe. Cliquez sur Création personnalisée et sur Soumettre.
- Création rapide : Ceci est plus facile, plus rapide et déploie automatiquement tous les éléments requis par OKE pour son fonctionnement, tels que :
  - Réseau en nuage virtuel (VCN)
  - Passerelle Internet (IG)
  - Passerelle NAT (NAT)
  - Passerelle de service (SGW)
  - grappe Kubernetes
  - noeuds de travail et groupe de noeuds Kubernetes
- Création personnalisée : Pour les environnements d'entreprise dans lesquels les clients disposent déjà de services, de réseau et d'infrastructure, il est important de personnaliser le déploiement OKE pour qu'il soit conforme, conforme à l'architecture et aux ressources du client et conforme aux meilleures pratiques.
  
  Dans ce tutoriel, nous sélectionnerons Création personnalisée pour conserver notre architecture affichée ci-dessus.
Entrez le nom, le compartiment, la version de Kubernetes de la grappe et cliquez sur Suivant.
Dans la page Configuration du réseau, entrez les informations suivantes et cliquez sur Suivant.
- Type de réseau : Sélectionnez Réseau de pod natif de VCN. Pour plus d'informations, voir Réseau du module de réseautage.
- VCN : Sélectionnez votre VCN.
- Sous-réseaux : Sélectionnez un sous-réseau privé et public. Dans ce tutoriel, nous utiliserons le sous-réseau public pour l'équilibreur de charge et le sous-réseau privé pour le point d'extrémité de l'API.
Dans la page Groupes de noeuds, entrez les informations suivantes.
- Nom : Entrez le nom du groupe de noeuds.
- Compartiment : Sélectionnez votre compartiment.
- Type de noeud : Sélectionnez le type de noeud Géré. Pour plus d'informations, voir Comparaison des noeuds virtuels et des noeuds gérés.
- Version : Sélectionnez la version de Kubernetes.
- Configuration du positionnement des noeuds :
  - domaine de disponibilité : Configurez le domaine de disponibilité.
  - Sous-réseau de noeuds de travail : Définissez le sous-réseau privé pour les noeuds qui seront créés dans ce groupe de noeuds.
  - Domaine d'erreur : Sélectionnez les domaines d'erreur où vous voulez que les noeuds soient répartis.
- Forme et image : Sélectionnez une forme et une image pour nos noeuds de travail,
  - 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 est suffisant.
- Volume de démarrage : Nous ne modifierons pas les paramètres du volume de démarrage.
- Communications par pod : Sélectionnez un sous-réseau privé.
Vérifiez la configuration de la grappe Kubernetes et cliquez sur Créer une grappe.

Note : Avant de cliquer sur Créer une grappe, assurez-vous que toutes les règles de liste de sécurité de trafic entrant et sortant ont été configurées dans chaque sous-réseau de réseau OKE pour l'équilibreur de charge, le point d'extrémité d'API et les noeuds de travail. Pour plus d'informations, voir Configuration de ressources de réseau pour la création et le déploiement de grappes.

Pour vérifier la grappe Kubernetes, naviguez jusqu'à Services de développement, Conteneurs et artefacts et Grappes Kubernetes (OKE).
Pour accéder à la grappe Kubernetes, cliquez sur le nom de la grappe Kubernetes et accédez à la grappe.

Vous pouvez voir 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 de point d'extrémité d'API, nous avons choisi un sous-réseau privé, qui est plus sécurisé et le seul moyen d'accéder à la grappe 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.

Note : Nous devons avoir installé l'interface de ligne de commande OCI, Docker et kubectl. Pour plus d'informations, voir Installation de kubectl.
Une fois l'hôte d'administration prêt, exécutez la commande suivante pour obtenir l'accès de votre machine locale à la grappe Kubernetes.
1. Vérifiez la version de l'interface de ligne de commande OCI.
```
oci -v
```
2. Créez un répertoire kubeconfig dans votre répertoire de base.
```
mkdir -p $HOME/.kube
```
3. Créez un fichier kubeconfig avec un point d'extrémité privé natif de 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
```
Pour vérifier l'accès à la grappe Kubernetes, exécutez des commandes kubectl.
- Obtenir les noeuds de travail OKE.
```
kubectl get nodes
```
- Obtenez les pods OKE.
```
kubectl get pods -A
```

Tâche 6 : Développer et déployer une application REST d'API dans Node.js et publier un message dans les avis OCI

Dans ce tutoriel, nous développerons et déploierons 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 le service d'avis OCI.

Nous allons créer un projet Node.js, le créer, le pousser vers le registre de conteneurs d'Oracle Cloud Infrastructure et le déployer dans OKE. Nous utiliserons un hôte d'administration Oracle Linux existant configuré pour le service des fonctions pour OCI, de sorte que nous avons déjà installé Node.js et Docker.

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
```
Pour initialiser un projet, exécutez la commande suivante et configurez le fichier package.json comme indiqué dans l'image suivante.
```
npm init
```
Avant de développer le code Node.js, nous devons installer les bibliothèques requises pour le projet.
- L'application REST d'API doit fonctionner comme une application Web. Nous aurons donc besoin d'une bibliothèque express.
```
npm install express
```
- Nous devrons obtenir le corps JSON à partir de la demande HTTP POST. Par conséquent, nous aurons besoin de la bibliothèque body-parser.
```
npm install body-parser
```
- 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
```
- Pour publier un message dans le service d'avis OCI qui provient du corps de la demande, nous aurons besoin de la bibliothèque oci-ons.
```
npm install oci-ons
```
Notre package.json comporte les dépendances suivantes.

Lorsque le projet Node.js est 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 nous avons configuré 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 de l'API, comme illustré dans l'image suivante.

Fichier de configuration dans le projet de restauration d'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}`);
});

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" ]

Créez et poussez l'image du projet dans le référentiel Docker local.
```
docker build . -t apirestapp:latest
```
Vérifiez l'image dans le référentiel Docker local.
```
docker images
```
Note :
- Vous devez avoir le registre de conteneurs pour Oracle Cloud Infrastructure. Reportez-vous à la tâche 3.6.
- Vous devez être connecté au registre de conteneurs d'Oracle Cloud Infrastructure, 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.
Nous pouvons marquer l'image d'application REST de l'API dans le registre de conteneurs pour Oracle Cloud Infrastructure.
```
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
```
Poussez l'image vers le registre de conteneurs d'Oracle Cloud Infrastructure.
```
docker push vcp.ocir.io/idccixxxxx/oke_application/oke_apirest_application_repository:latest
```
Pour vérifier l'application d'image OKE dans le registre de conteneurs d'Oracle Cloud Infrastructure, allez à Services de développement, Conteneurs et artefacts et Registre de conteneurs.
Une fois l'image dans le registre de conteneurs Oracle Cloud Infrastructure, nous pouvons aller à l'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 pour 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éer un espace de noms pour OKE.
```
kubectl create namespace ns-tutorial
```
3. Vérifiez l'espace de noms.
```
kubectl get namespace ns-tutorial
```
4. Créer une clé secrète pour OKE.
```
kubectl create secret -n ns-tutorial generic ocir --from-file=.dockerconfigjson=../.docker/config.json --type=kubernetes.io/dockerconfigjson
```
5. Vérifiez la clé secrète.
```
kubectl get secrets -A
```
Nous avons déjà un environnement OKE prêt pour le déploiement de l'image d'application d'Oracle Cloud Infrastructure Container Registry vers OKE.

Note : 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,
- Pour valider le pod et le service créés dans OKE, exécutez la commande suivante.
```
kubectl get pods -A
```
```
kubectl get svc -A
```
Note : Téléchargez le projet d'application REST API à partir d'ici : api_rest_application_oke.zip.

Tâche 7 : Demander une POST HTTP avec corps JSON à l'URL exposée dans l'équilibreur de charge de l'application REST d'API

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

Pour installer Postman, voir Installation de Postman.
Ouvrez l'application Postman.
1. Cliquez sur le menu hamburger, sur Fichier et sélectionnez Nouveau.
2. Sélectionnez HTTP.
3. Entrez l'URL exposé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 le marqueur Corps, sélectionnez brut et entrez le message JSON dans le champ vide.
Cliquez sur envoyer pour envoyer la demande.

Pour vérifier le fichier créé dans le seau spécifique du stockage d'objets OCI, allez à Stockage, Stockage d'objets et stockage d'archives, Seaux et cliquez sur votre seau.

Dans ce tutoriel, vous avez utilisé le service d'avis pour OCI avec un nouveau cas d'utilisation, en intégrant plusieurs services tels que les API, la trousse SDK pour OCI et les applications Kubernetes déployées dans OKE, le service des fonctions pour OCI et le service de stockage d'objets pour OCI.

Confirmation

Auteur - Iván Alexander Vásquez Chinome (spécialiste de la solution en nuage pour l'équipe A d'Oracle LAD)

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

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

Titre et droits d'auteur

Publish a Message in OCI Notifications, Trigger a Function and Create a File in OCI Object Storage Bucket

F96548-01

April 2024

Oracle et/ou ses sociétés affiliées.