Nota

Pubblicare un messaggio in OCI Notifiche, attivare una funzione e creare un file nel bucket di storage degli oggetti OCI

Introduzione

È possibile configurare un servizio di sottoscrizione pubblicazione, ad esempio le notifiche di Oracle Cloud Infrastructure (OCI), che esegue il push dei messaggi agli endpoint che possono inviare avvisi e agire tramite la sottoscrizione configurata; non solo supporta l'uso di Oracle Cloud Infrastructure Monitoring o OCI Connector Hub casi, ma anche gli eventi possono essere generati dalle applicazioni dei clienti, messaggi API che devono rappresentare un'azione immediata da eseguire quando l'applicazione invia un messaggio quando un evento attiva OCI Notifications.

L'architettura può essere più o meno complessa, ma per questo caso d'uso il client effettua una richiesta HTTP POST, inviando nel corpo un JSON che ha determinati attributi a creare un file, ad esempio il nome file, il nome del bucket in cui si desidera creare il file in OCI Object Storage e il messaggio che si troverà all'interno del file.

L'applicazione REST API distribuita in Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) e sviluppata in Node.js ottiene la notazione JSON dal corpo della richiesta e anche in questa applicazione le librerie OCI vengono utilizzate per pubblicare un messaggio in OCI Notifications con una funzione Node.js sottoscritta e sviluppata per creare il file di testo in un bucket specifico in OCI Object Storage con i parametri JSON inviati.

Architettura OCI

Architettura OCI

Architettura del caso d'uso

Architettura del caso d'uso

In questa esercitazione verrà avviata la configurazione dall'ultimo servizio fino a raggiungere il primo in Oracle Cloud Infrastructure (OCI):

Obiettivi

Prerequisiti

Task 1: creare un bucket in OCI Object Storage

  1. Eseguire il login a OCI Console, passare a Storage, Storage degli oggetti e storage di archivio, Bucket e selezionare il Compartimento desiderato.

  2. Fare clic su Crea bucket e immettere le informazioni seguenti.

    • Nome gruppo: immettere il nome del gruppo. Ad esempio, data o un altro nome.
    • Livello di storage predefinito: per questa esercitazione, selezionare Standard.
    • Cifratura: selezionare Cifra mediante chiavi gestite da Oracle.
    • Log delle risorse: selezionare Log delle risorse abilitato per avere osservabilità su ciò che accade nel bucket.

    Crea bucket

Task 2: configurare e creare funzioni OCI

  1. Andare alla console OCI, andare a Servizi sviluppatore, Funzioni, Applicazioni e selezionare Compartimento.

  2. Fare clic su Crea applicazione e immettere le informazioni seguenti.

    • Nome: immettere il nome dell'applicazione di funzione.
    • VCN: selezionare la VCN creata nei prerequisiti.
    • Subnet: selezionare la subnet creata nei prerequisiti. In questa esercitazione è stata configurata una subnet pubblica.
    • Forma: selezionare la forma correlata al processore supportato da questa applicazione. Per questo tutorial, è GENERIC_X86.

    Crea applicazione funzione

  3. Abilitare i log per tenere traccia dell'esecuzione e visualizzare gli errori dell'applicazione OCI Functions. Pertanto, nei dettagli dell'applicazione di funzione, in Risorse fare clic su Log e selezionare Abilita log per configurare il compartimento, Gruppo di log, Nome log e l'ora della Conservazione log.

    Abilita applicazione funzione log

Task 3: configurare, sviluppare e eseguire il push delle funzioni OCI utilizzando FDK Node.js per creare un nuovo file di testo

Configura, sviluppa e invia tramite push un OCI Functions utilizzando FDK Node.js per creare un nuovo file di testo in un bucket specifico dai parametri JSON.

Nota: configurare il client come: Desktop, PC, Laptop o Virtual Machine (VM) e il contesto della funzione in cui si lavorerà con Fn Project, poiché OCI Functions è alimentato dal motore open source Fn Project per eseguire operazioni di creazione, lettura, aggiornamento ed eliminazione su OCI Functions.

Utilizzeremo una VM Oracle Linux 8 (host amministratore) in OCI come mostrato nell'architettura di Introduzione.

  1. Andare a OCI Console, andare a Servizi per sviluppatori, Funzioni, Applicazioni e fare clic sull'applicazione della funzione.

  2. Nella sezione Risorse, fare clic su Inizia e selezionare Impostazione locale per utilizzare una VM Oracle Linux esterna.

    Impostazione locale

    Nota: è necessario aver installato i seguenti componenti.

    • Acronimo di OCI Command Line Interface (CLI).

    • Node.js in Oracle Linux.

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

      La versione di Node.js deve essere supportata dalle funzioni FDK OCI.

      Versione supportata nelle funzioni OCI - node.js

      Se la versione non è supportata, è necessario eseguire i comandi seguenti.

      Esempio:

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

    • CLI Fn Project installata nella VM. Per ulteriori informazioni, vedere Installazione dell'interfaccia CLI di Fn Project.

  3. Crea il tuo progetto nel linguaggio di programmazione desiderato. In questo tutorial, useremo Node.js. Per creare un nuovo progetto, eseguire il comando seguente.

    fn init --runtime node "Name_Of_Your_Project"

    Esempio:

    fn init --runtime node app_mess_createFile_os_function

  4. Per accedere alla cartella del progetto, eseguire il comando seguente.

    cd "Name_Of_Your_Project"/

    Esempio:

    cd app_mess_createFile_os_function/

  5. Crea e aggiorna un contesto specifico per il compartimento e l'URL dell'API Oracle Functions per l'area specificata nella Guida introduttiva.

    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"

    Esempio:

    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. Immettere il percorso di Oracle Cloud Infrastructure Container Registry in cui verrà eseguito il push dell'immagine dell'applicazione.

    Nota: se non si dispone di Oracle Cloud Infrastructure Container Registry, è necessario creare questo repository per eseguire il PUSH dell'immagine della funzione.

    1. Andare a Servizi sviluppatore, Container e artifact, Container Registry e fare clic su Crea repository.

    2. Immettere le informazioni seguenti e fare clic su Crea.

      • Crea nel compartimento: selezionare il compartimento,
      • Accesso: selezionare Pubblico.
      • nome repository: immettere il nome del repository.

      Creazione di Oracle Cloud Infrastructure Container Registry

    Una volta che si è certi di aver creato Oracle Cloud Infrastructure Container Registry, impostare il percorso di questo repository fino al prefisso nel contesto.

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

    Esempio:

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

  7. Eseguire il login a Oracle Cloud Infrastructure Container Registry.

    Nota: per eseguire il login, creare, estrarre ed eseguire il push delle immagini nel repository, è necessario disporre dei seguenti elementi:

    Eseguire il comando riportato di seguito per eseguire il login a Oracle Cloud Infrastructure Container Registry.

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

    Password: xxxxxx

    Esempio (ad esempio, il nome utente viene federato con Oracle Identity Cloud Service e deve essere incluso):

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

    Password: xxxxxx

    Login

  8. Una volta configurate le funzioni OCI, svilupperemo il programma Node.js per creare un file di testo in un bucket specifico.

    Abbiamo creato un progetto funzionale nel Task 3.3, che crea i seguenti file nella cartella del progetto:

    • func.js (in questo file scriviamo la logica del progetto node.js).
    • func.yaml (questo è il file di configurazione della funzione).
    • package.json (questo file specifica le dipendenze Node.js richieste per la logica del progetto).

    In questo progetto, sarà necessario aggiungere le seguenti dipendenze dell'SDK OCI Node.js; oci-objectstorage e oci-common. Eseguire il comando riportato di seguito per installare le dipendenze.

    npm install oci-common

    Aggiunta dipendenza oci-common

    npm install oci-objectstorage

    Aggiunta della dipendenza oci-objectstorage

    È possibile visualizzare le dipendenze aggiunte nel file package.json.

    Dipendenze aggiunte

    Verrà eseguita l'autenticazione in OCI dal codice utilizzando il file di configurazione, in modo simile al processo di configurazione dell'interfaccia CLI OCI in cui le chiavi e il file di configurazione sono stati inseriti nella cartella Progetto Fn.

    Cartella progetto funzione

    Di seguito è riportato il codice sorgente Node.js e il dettaglio di ogni frammento di codice viene spiegato con i commenti.

    • 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;
}

    Nota: scaricare OCI Functions Project da qui: app_mess_createFile_os_function.zip.

  9. Il progetto è stato creato. Assicurarsi di rimanere connessi a Oracle Cloud Infrastructure Container Registry. Creeremo e invieremo l'immagine in Oracle Cloud Infrastructure Container Registry e distribuiremo questa funzione nell'applicazione OCI Functions.

    1. Andare a OCI Console, andare a Servizi per sviluppatori, Funzioni, Applicazioni e fare clic sull'applicazione della funzione.

      Nel nostro computer locale, dobbiamo essere nella cartella del progetto OCI Functions.

      fn deploy --app name_of_your_function_application

      Esempio:

      fn deploy --app fn-demo-apgw

      Distribuisci funzione in Oracle Cloud Infrastructure Container Registry

    2. Per verificare che l'immagine sia stata distribuita in Oracle Cloud Infrastructure Container Registry, andare alla console OCI e andare a Servizi per sviluppatori, Container e artifact e Container Registry.

      Esegui check-in immagine console OCI sottoposta a push in Oracle Cloud Infrastructure Container Registry

      Per verificare se la funzione è distribuita nell'applicazione OCI Functions, andare alla console OCI e andare a Servizi sviluppatore, Funzioni, Applicazioni, fare clic sull'applicazione della funzione e vedere che vi viene fatto riferimento all'immagine con il percorso Oracle Cloud Infrastructure Container Registry.

      Eseguire il check-in dell'immagine di OCI Console distribuita in OCI Functions

  10. Eseguire un test dal computer locale, eseguire il comando Fn Project seguente simulando un input con i parametri forniti da un formato JSON.

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

    Esempio:

    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

    Richiamo della funzione

    Per esaminare il file creato nel bucket, andare a Storage, Storage degli oggetti e storage di archivio, Bucket, quindi fare clic sul bucket e verificare che il file sia presente.

    Convalida del bucket

    Analisi del file

Task 4: creare un nuovo argomento OCI Notifications e una sottoscrizione che associa un OCI Functions come endpoint

  1. Crea e utilizza le notifiche OCI. Quando un messaggio viene pubblicato in un argomento all'interno di questo servizio, genera un trigger per un endpoint. Questo endpoint sarà la funzione creata nel task 3.

    Andare a OCI Console, andare a Servizi per sviluppatori, Integrazione delle applicazioni e Notifiche. Fare clic su Crea argomento e immettere il nome per questo argomento.

    Creazione di un argomento nelle notifiche OCI

    Argomento creato nelle notifiche OCI

  2. Per creare una sottoscrizione per questo argomento, fare clic sull'argomento e su Crea sottoscrizione. In questa esercitazione verrà selezionato Functions come endpoint. È possibile selezionare un endpoint quali Posta elettronica, Slack, SMS, PagerDuty o URL HTTPS e selezionare il compartimento funzione, l'applicazione Oracle Functions e la funzione.

    Creazione sottoscrizione

    Abbonamento creato

    Nota: in OCI Notifications, possiamo creare più sottoscrizioni con un endpoint diverso, se necessario.

  3. Da OCI Notifications, possiamo pubblicare un messaggio in formato JSON con le variabili richieste simili a quelle del task 3 per OCI Functions.

    Andare a OCI Console, andare a Servizi per sviluppatori, Integrazione delle applicazioni e Notifiche. Fare clic sull'argomento e immettere il messaggio come mostrato nella seguente immagine.

    Esecuzione della notifica OCI

    Per eseguire la verifica nel bucket, andare a Storage, Storage degli oggetti e storage di archivio e Bucket. Fare clic sul bucket e verificare se il file è presente.

    Test da notifica OCI

    Analisi del file di test creato dalla notifica OCI

Task 5: Creare e configurare un cluster Kubernetes in Oracle Cloud Infrastructure Container Engine for Kubernetes

In questo task verrà creato un semplice cluster Kubernetes. Per ulteriori informazioni, vedere Creazione di un cluster OKE.

  1. Andare alla console OCI, andare a Servizi per sviluppatori, Container e artifact e fare clic su Cluster Kubernetes (OKE).

  2. Nella pagina Cluster fare clic su Crea cluster.

  3. Sono disponibili due flussi di lavoro per creare il cluster. Fare clic su Creazione personalizzata e su Sottometti.

    • Creazione rapida: questa operazione è più semplice, rapida e distribuisce automaticamente tutti gli elementi richiesti da OKE per il relativo funzionamento, ad esempio:

      • Virtual Cloud Network (VCN)
      • Gateway Internet (IG)
      • Gateway NAT (NAT)
      • Gateway del servizio (SGW)
      • Cluster Kubernetes
      • Uno o più nodi di lavoro e un pool di nodi Kubernetes

    • Creazione personalizzata: per gli ambienti aziendali, in cui già i clienti dispongono di servizi, rete, infrastruttura, è importante personalizzare l'implementazione OKE, in modo che sia conforme, in linea con l'architettura client, le risorse e seguendo le best practice.

      In questa esercitazione verrà selezionata l'opzione Creazione personalizzata per conservare l'architettura mostrata in precedenza.

    Opzioni per la creazione del cluster OKE

  4. Immettere il nome, il compartimento e la versione Kubernetes del cluster, quindi fare clic su Avanti.

    Crea cluster

  5. Nella pagina Impostazione di rete, immettere le informazioni riportate di seguito e fare clic su Avanti.

    • Tipo di rete: selezionare Native pod networking VCN. Per ulteriori informazioni, vedere Rete POD.
    • VCN: selezionare la VCN.
    • Subnet: selezionare la subnet pubblica e privata. In questa esercitazione viene utilizzata la subnet pubblica per il load balancer e la subnet privata per l'endpoint API.

    Impostazione rete

  6. Nella pagina Pool di nodi immettere le informazioni riportate di seguito.

    • Nome: immettere il nome del pool di nodi.
    • Compartimento: selezionare il compartimento.
    • Tipo di nodo: selezionare il tipo di nodo Gestito. Per ulteriori informazioni, vedere Confronto dei nodi virtuali con i nodi gestiti.
    • Versione: selezionare la versione di Kubernetes.
    • Configurazione posizionamento dei nodi:
      • Dominio di disponibilità: configurare il dominio di disponibilità.
      • Subnet del nodo del lavoratore: impostare la subnet privata per i nodi che verranno creati in questo pool di nodi.
      • Dominio di errore: selezionare i domini di errore in cui si desidera distribuire i nodi.
    • Forma e immagine: selezionare una forma e un'immagine per i nodi di lavoro,
      • Forma nodo: selezionare VM.Standard.E3.Flex Shape (16GB RAM memory and 1 OCPU).
      • Immagine: selezionare l'immagine Oracle-Linux-8.9-2024.01.26-0-OKE-1.28.2-679.
    • Conteggio nodi: immettere 1, per questa esercitazione è sufficiente 1.
    • Volume di avvio: i parametri del volume di avvio non verranno modificati.
    • Comunicazioni pod: selezionare una subnet privata.

    Pool di nodi 1

    Pool di nodi 2

  7. Rivedere la configurazione del cluster Kubernetes e fare clic su Crea cluster.

    Nota: prima di fare clic su Crea cluster, assicurarsi che tutte le regole della lista di sicurezza in entrata e in uscita siano state configurate in ogni subnet di rete OKE per il load balancer, l'endpoint API e i nodi di lavoro. Per ulteriori informazioni, vedere Configurazione delle risorse di rete per la creazione e la distribuzione del cluster.

    Rivedi OKE

    Per verificare il cluster Kubernetes, passare a Servizi per sviluppatori, Container e artifact e Cluster Kubernetes (OKE).

    Cluster OKE creato

  8. Per accedere al cluster Kubernetes, fare clic sul nome del cluster Kubernetes e su Accedi al cluster.

    È possibile che l'accesso a Cloud Shell sia disabilitato e che l'accesso locale sia abilitato, poiché quando è stata selezionata la subnet dell'endpoint API, è stata scelta una subnet privata, che è più sicuro e l'unico modo per accedere al cluster Kubernetes è utilizzare un computer locale, quindi è esattamente la configurazione che stiamo utilizzando in questa esercitazione con il nostro host amministratore Oracle Linux VM. Selezionare Accesso locale.

    Accesso a cluster

    Nota: è necessario aver installato l'interfaccia CLI OCI, Docker e kubectl. Per maggiori informazioni, vedere Installazione di kubectl.

  9. Quando l'host di amministrazione è pronto, eseguire il comando riportato di seguito per ottenere l'accesso dal computer locale al cluster Kubernetes.

    1. Verificare la versione dell'interfaccia CLI OCI.

      oci -v

    2. Creare la directory kubeconfig nella home.

      mkdir -p $HOME/.kube

    3. Creare un file kubeconfig con un endpoint privato nativo della 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. Impostare la variabile di ambiente kubeconfig.

      export KUBECONFIG=$HOME/.kube/config

  10. Per verificare l'accesso del cluster Kubernetes, eseguire i comandi kubectl.

    • Ottenere i nodi di lavoro OKE.

      kubectl get nodes

      nodi get kubectl

    • Scarica i pod OKE.

      kubectl get pods -A

      kubectl ottiene i pod

Task 6: sviluppare e distribuire un'applicazione REST API in Node.js e pubblicare il messaggio nelle notifiche OCI

In questa esercitazione svilupperemo e distribuiremo un'applicazione REST API in Node.js per ottenere il file JSON dal corpo della richiesta HTTP Post e pubblicare questo corpo JSON come messaggio in OCI Notifications.

Verrà creato un progetto Node.js, creato il progetto, inviato tramite push a Oracle Cloud Infrastructure Container Registry e distribuito in OKE. Verrà utilizzato un host di amministrazione Oracle Linux esistente configurato per OCI Functions in modo da avere già installato Node.js e Docker.

  1. Eseguire i seguenti comandi per creare una cartella con il nome del progetto nella home locale del computer e passare alla cartella del progetto.

    mkdir api_rest_application_oke

    cd api_rest_application_oke

  2. Per inizializzare un progetto, eseguire il comando seguente e configurare il file package.json come mostrato nella seguente immagine.

    npm init

    progetto nodejs

  3. Prima di sviluppare il codice Node.js, è necessario installare le librerie necessarie per il progetto.

    • L'applicazione REST API deve funzionare come un'applicazione Web, pertanto sarà necessaria la libreria di espressioni.

      npm install express

      Installazione della libreria express

    • È necessario ottenere il corpo JSON dalla richiesta HTTP POST, pertanto sarà necessaria la libreria body-parser.

      npm install body-parser

      Installazione della libreria body-parser

    • L'applicazione dovrà eseguire l'autenticazione con OCI per avere accesso ai propri servizi, pertanto sarà necessaria la libreria oci-common.

      npm install oci-common

      Installazione di oci-common Library

    • Per pubblicare un messaggio nel servizio di notifiche OCI proveniente dal corpo della richiesta, sarà necessaria la libreria oci-ons.

      npm install oci-ons

      Installazione della libreria oci-ons

    Il nostro package.json ha le seguenti dipendenze.

    File package.json

  4. Quando si configura il progetto Node.js, è possibile creare il codice nel file index.js. Di seguito è riportato il codice sorgente.

    Verrà eseguita l'autenticazione in OCI dal codice utilizzando il file di configurazione, in modo simile al modo in cui è stata configurata l'interfaccia CLI OCI. In entrambi i casi, le chiavi e il file di configurazione vengono posizionati nella cartella del progetto dell'applicazione REST API, come mostrato nella seguente immagine.

    File di configurazione nel progetto API Rest

    • 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. Nella stessa cartella, creare Dockerfile, che consentirà di creare un'immagine contenitore.

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

  6. Crea ed esegui il push dell'immagine del progetto nel repository Docker locale.

    docker build . -t apirestapp:latest

    Immagine docker build

    Verificare l'immagine nel repository Docker locale.

    docker images

    Controlla immagini docker

    Nota:

    • Devi disporre di Oracle Cloud Infrastructure Container Registry. Fare riferimento al task 3.6.

      Creazione del repository dell'applicazione OKE

    • È necessario aver eseguito il login a Oracle Cloud Infrastructure Container Registry poiché stiamo utilizzando lo stesso host di amministrazione del computer locale a cui dovremmo essere collegati. Fare riferimento al task 3.7.

  7. Possiamo contrassegnare l'immagine dell'applicazione REST API in Oracle Cloud Infrastructure Container Registry.

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

    Verificare nel repository Docker locale.

    docker images

    Contrassegna applicazione OKE

    Esegui il push dell'immagine in Oracle Cloud Infrastructure Container Registry.

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

    Applicazione OKE push

    Per esaminare l'applicazione di immagini OKE in Oracle Cloud Infrastructure Container Registry, vai a Servizi per sviluppatori, Container e artifact e Container Registry.

    Immagine nel registro OKE Containe

  8. Una volta che l'immagine si trova in Oracle Cloud Infrastructure Container Registry, possiamo andare al nostro host di amministrazione VM Oracle Linux locale e distribuire questa immagine in OKE. Per questa esercitazione, eseguire il comando riportato di seguito per creare lo spazio di nomi e il segreto per OKE.

    1. Accedere alla cartella del progetto.

      cd api_rest_application_oke/

    2. Creare uno spazio di nomi per OKE.

      kubectl create namespace ns-tutorial

      Crea oke dello spazio di nomi

    3. Verificare lo spazio di nomi.

      kubectl get namespace ns-tutorial

      Verifica spazio di nomi oke

    4. Creare un segreto per OKE.

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

      Crea OA secrete

    5. Verificare il segreto.

      kubectl get secrets -A

      Verifica oke segreto

  9. L'ambiente OKE è già pronto, quindi distribuire l'immagine dell'applicazione da Oracle Cloud Infrastructure Container Registry a OKE.

    Nota: per distribuire l'immagine dell'applicazione, è necessario disporre di un file manifest. In questa esercitazione il file yaml seguente è il file manifest, utilizzato per distribuire l'applicazione e creare il servizio in entrata rappresentato in un load balancer OCI in ascolto utilizzando la porta 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

    • Eseguire il comando kubectl nella cartella in cui è stato salvato il file manifesto.

      kubectl apply -f apirest_application_manifest.yaml

      Ora l'applicazione viene distribuita e il servizio load balancer in entrata viene creato in OKE,

      Applica manifesto in OKE

    • Per convalidare il pod e il servizio creati in OKE, eseguire il comando seguente.

      kubectl get pods -A

      OKE PODS

      kubectl get svc -A

      Servizi OKE

    Nota: scaricare il progetto dell'applicazione REST API da qui: api_rest_application_oke.zip.

Task 7: richiedere POST HTTP con corpo JSON all'URL esposto nel load balancer dell'applicazione REST API

In questo task verrà eseguita una richiesta HTTP POST con il corpo del messaggio JSON dal client Postman contenente i dati di base per creare un file in un bucket. Questa richiesta verrà inviata all'applicazione REST API in OKE e il push del messaggio nell'argomento Notifiche OCI attiverà una funzione con la logica per creare un file di testo in un bucket specifico, come illustrato nell'architettura di Introduzione.

  1. Per installare Postman, vedere Postman Installation.

  2. Apri l'applicazione Postman.

    1. Fare clic sul menu hamburger, File e selezionare Nuovo.

      Menu Poster

    2. Selezionare HTTP.

      Opzione HTTP

    3. Immettere l'URL esposto dall'applicazione REST API distribuita in OKE: http://"IP ADDRESS LOAD BALANCER"/api/receive-json e selezionare il metodo POST. Nel tag Corpo selezionare raw e immettere il messaggio JSON nel campo vuoto.

      Richiesta postale

  3. Fare clic su Invia per inviare la richiesta.

    Postino richiesta risposta

    Per verificare il file creato nel bucket specifico in OCI Object Storage, andare a Storage, Storage degli oggetti e Storage di archivio, Bucket e fare clic sul bucket.

    Ultimo file creato in un bucket specifico in questa esercitazione

    Ultimo file di testo

In questa esercitazione, hai utilizzato le notifiche OCI con un nuovo caso d'uso, integrando diversi servizi come API, SDK OCI, applicazioni Kubernetes distribuite in OKE, OCI Functions e OCI Object Storage.

Conferme

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare un Oracle Learning Explorer.

Per la documentazione del prodotto, visita l'Oracle Help Center.