Note:

Este tutorial requiere acceso a Oracle Cloud. Para registrarse en una cuenta gratuita, consulte Introducción a la capa gratuita de Oracle Cloud Infrastructure.
Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al completar el laboratorio, sustituya estos valores por otros específicos de su entorno en la nube.

Publicación de un mensaje en OCI Notifications, activación de una función y creación de un archivo en un cubo de OCI Object Storage

Introducción

Puede configurar un servicio de suscripción de publicación como Oracle Cloud Infrastructure (OCI) Notifications que envíe mensajes a puntos finales que puedan alertar y realizar acciones a través de la suscripción configurada; no solo soporta el uso de Oracle Cloud Infrastructure Monitoring u OCI Connector Hub casos, pero también los eventos se pueden generar a partir de las aplicaciones del cliente, mensajes de API que deben representar una acción inmediata que se debe ejecutar cuando la aplicación envía un mensaje cuando un evento dispara OCI Notifications.

La arquitectura puede ser más o menos compleja, pero para este caso de uso el cliente realiza una solicitud HTTP POST, enviando en el cuerpo un JSON que tiene ciertos atributos a Crear un archivo, como el nombre de archivo, el nombre del cubo en el que desea crear el archivo en OCI Object Storage y el mensaje que estará dentro del archivo.

A continuación, la aplicación REST de API desplegada en Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) y desarrollada en Node.js obtiene el JSON del cuerpo de la solicitud y, también en esta aplicación, las bibliotecas de OCI se utilizan para publicar un mensaje en OCI Notifications que ya tenga una función Node.js suscrita y desarrollada para crear el archivo de texto en un cubo específico de OCI Object Storage con los parámetros JSON enviados.

Arquitectura de OCI

Arquitectura de OCI

Arquitectura de casos de uso

Arquitectura de casos de uso

En este tutorial, vamos a empezar a configurar desde el último servicio hasta que lleguemos al primero en Oracle Cloud Infrastructure (OCI):

OCI Object Storage
OCI Functions
Notifications
Oracle Cloud Infrastructure Container Engine for Kubernetes

Objetivos

Cree un nuevo cubo de OCI Object Storage.
Configurar y crear OCI Functions.
Configure, desarrolle y transfiera OCI Functions mediante el kit de desarrollo de funciones (FDK) Node.js para crear un nuevo archivo de texto en un cubo específico a partir de parámetros JSON.
Cree un tema nuevo en OCI Notifications y cree una suscripción que asocie OCI Functions como punto final.
Crear y configurar un cluster de Kubernetes en OKE.
Desarrolle y despliegue una aplicación REST de API en Node.js para obtener el JSON del cuerpo de solicitud HTTP POST y publicar este cuerpo de JSON como mensaje en OCI Notifications.
Solicite POST HTTP con un cuerpo JSON a la URL expuesta en el equilibrador de carga de la aplicación REST de API.

Requisitos

Acceso a un inquilino de OCI. Para crear una cuenta gratuita de Oracle Cloud, consulte Creación de una cuenta gratuita de Oracle Cloud.
Instalar la interfaz de línea de comandos (CLI) de OCI. Para obtener más información, consulte Instalación de la CLI de OCI.
Cree una VCN con subredes públicas y privadas. Para obtener más información, consulte Creación de una VCN y Creación de una subred.
Cree una tabla de rutas para el tráfico de acceso a Internet con el gateway de Internet. Para obtener más información, consulte Tablas de rutas de VCN y Gateway de Internet.
Cree un compartimento donde pueda agrupar sus servicios de OCI. Para obtener más información, consulte Creación de un compartimento.

Tarea 1: Creación de un cubo en OCI Object Storage

Conéctese a la consola de OCI, vaya a Storage, Object Storage & Archive Storage, Buckets y seleccione el compartimento de su preferencia.
Haga clic en Crear cubo e introduzca la siguiente información.
- Nombre del cubo: introduzca el nombre del cubo. Por ejemplo, data u otro nombre.
- Nivel de almacenamiento por defecto: para este tutorial, seleccione Estándar.
- Encifrado: seleccione Cifrar con claves gestionadas por Oracle.
- Registro de recursos: seleccione Registro de recursos activado para que se pueda observar lo que ocurre en el cubo.

Tarea 2: Configuración y creación de funciones de OCI

Vaya a la consola de OCI, vaya a Servicios para desarrolladores, Funciones, Aplicaciones y seleccione Compartimento.
Haga clic en Crear aplicación e introduzca la siguiente información.
- Nombre: introduzca el nombre de la aplicación de función.
- VCN: seleccione la VCN creada en los requisitos.
- Subredes: seleccione la subred creada en los requisitos. En este tutorial, hemos configurado una subred pública.
- Unidad: seleccione la unidad relacionada con el procesador que soporta esta aplicación. Para este tutorial, es GENERIC_X86.
Active los logs para realizar un seguimiento de la ejecución y ver los errores de la aplicación OCI Functions, por lo que en el detalle de la aplicación de función, en Recursos, haga clic en Logs y seleccione Activar log para configurar el compartimento, Grupo de logs, Nombre de log y la hora de la Retención de log.

Tarea 3: Configuración, desarrollo y transferencia de OCI Functions mediante FDK Node.js para crear un nuevo archivo de texto

Configure, desarrolle y transfiera funciones de OCI mediante FDK Node.js para crear un nuevo archivo de texto en un cubo específico a partir de parámetros JSON.

Nota: Configure el cliente como: Escritorio, PC, portátil o máquina virtual (VM) y el contexto de la función en la que trabajará con Fn Project, porque OCI Functions cuenta con la tecnología del motor de código abierto Fn Project para realizar operaciones de creación, lectura, actualización y supresión en OCI Functions.

Utilizaremos una máquina virtual de Oracle Linux 8 (host de administrador) en OCI, como se ve en la arquitectura de Introducción.

Vaya a la consola de OCI, vaya a Developer Services, Functions, Applications y haga clic en la aplicación de función.
En la sección Recursos, haga clic en Introducción y seleccione Configuración local para utilizar una máquina virtual de Oracle Linux externa.
Nota: Debe tener instalados los siguientes componentes.
- Interfaz de línea de comandos (CLI). de OCI
- Node.js en Oracle Linux.
  sudo yum update sudo yum install -y nodejs node --version
  La versión de Node.js debe estar soportada por OCI FDK Functions.
  
  Si la versión no está soportada, es necesario ejecutar los siguientes comandos.
  
  Por ejemplo:
  sudo yum module reset nodejs sudo yum module enable nodejs:18 sudo yum module install nodejs
- CLI de Fn Project instalada en la VM. Para obtener más información, consulte Installing the Fn Project CLI.
Cree el proyecto en el lenguaje de programación deseado. En este tutorial, utilizaremos Node.js. Para crear un nuevo proyecto, ejecute el siguiente comando.
```
fn init --runtime node "Name_Of_Your_Project"
```
Por ejemplo:
```
fn init --runtime node app_mess_createFile_os_function
```
Para acceder a la carpeta del proyecto, ejecute el siguiente comando.
```
cd "Name_Of_Your_Project"/
```
Por ejemplo:
```
cd app_mess_createFile_os_function/
```

Cree y actualice un contexto específico para nuestro compartimento y la URL de API de Oracle Functions para la región especificada en Introducción.

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"

Por ejemplo:

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

Introduzca la ruta de acceso de Oracle Cloud Infrastructure Container Registry donde se transferirá la imagen de la aplicación.
Nota: Si no tiene Oracle Cloud Infrastructure Container Registry, debe crear este repositorio para transferir la imagen de función.
1. Vaya a Servicios para desarrolladores, Contenedores y artefactos, Container Registry y haga clic en Crear repositorio.
2. Introduzca la siguiente información y haga clic en Crear.
  - Crear en compartimento: seleccione su compartimento.
  - Acceso: seleccione Público.
  - nombre de repositorio: introduzca el nombre del repositorio.
Una vez que esté seguro de que ha creado Oracle Cloud Infrastructure Container Registry, defina la ruta de acceso de este repositorio hasta el prefijo en el contexto.
```
fn update context registry "regionID.ocir.io/tenancy_namespace/[repo-name-prefix]"
```
Por ejemplo:
```
fn update context registry vcp.ocir.io/idccixxxxx/apigwrepo
```
Conectarse a Oracle Cloud Infrastructure Container Registry.
Nota: Para conectarse, cree, extraiga y transfiera imágenes al repositorio que debe tener:
- Docker instalado. Para obtener más información, consulte How to install Docker on Oracle Linux 8/7.
- Nombre de usuario y token de autenticación de Oracle Cloud Infrastructure creados. Para obtener más información, consulte Obtención de un token de autenticación.
Ejecute el siguiente comando para conectarse a Oracle Cloud Infrastructure Container Registry.
```
sudo docker login -u 'tenancy_namespace/username' regionID.ocir.io
```
```
Password: xxxxxx
```
Ejemplo (En este ejemplo, el nombre de usuario está federado con Oracle Identity Cloud Service, por lo que se debe incluir):
```
sudo docker login -u 'idccixxxxx/OracleIdentityCloudService/ivan.v.vasquez@oracle.com' vcp.ocir.io
```
```
Password: xxxxxx
```

Una vez que haya configurado OCI Functions, desarrollaremos el programa Node.js para crear un archivo de texto en un cubo específico.

Hemos creado el proyecto de función en la Tarea 3.3, crea los siguientes archivos en la carpeta del proyecto:

func.js (En este archivo escribimos la lógica del proyecto node.js).
func.yaml (este es el archivo de configuración de la función).
package.json (este archivo especifica las dependencias Node.js necesarias para la lógica del proyecto).

En este proyecto, necesitaremos agregar las siguientes dependencias de SDK de OCI Node.js; oci-objectstorage y oci-common. Ejecute el siguiente comando para instalar dependencias.

npm install oci-common

Adición de dependencia oci-common

npm install oci-objectstorage

Adición de oci-objectstorage de dependencia

Podemos ver las dependencias agregadas en el archivo package.json.

Dependencias agregadas

Vamos a autenticar en OCI desde el código mediante el archivo de configuración, de forma similar al proceso de configuración de la CLI de OCI, donde tanto las claves como el archivo de configuración se colocaron en la carpeta Fn Project.

Carpeta de Proyecto de Función

El siguiente es el código fuente Node.js, y el detalle de cada fragmento de código se explica con comentarios.

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: Descargue el proyecto de OCI Functions desde aquí: app_mess_createFile_os_function.zip.

Se crea el proyecto, asegúrese de que permanece conectado a Oracle Cloud Infrastructure Container Registry. Vamos a crear y transferir la imagen en Oracle Cloud Infrastructure Container Registry y desplegar esta función en la aplicación OCI Functions.
1. Vaya a la consola de OCI, vaya a Developer Services, Functions, Applications y haga clic en la aplicación de función.
  
  En nuestra máquina local, debemos estar en la carpeta de proyectos de OCI Functions.
```
fn deploy --app name_of_your_function_application
```
  Por ejemplo:
```
fn deploy --app fn-demo-apgw
```
2. Para validar que la imagen se ha desplegado en Oracle Cloud Infrastructure Container Registry, vaya a la consola de OCI y vaya a Servicios para desarrolladores, Contenedores y artefactos y Container Registry.
  
  Para comprobar si la función está desplegada en la aplicación OCI Functions, vaya a la consola de OCI y vaya a Developer Services, Functions, Applications, haga clic en la aplicación de función y vea que se hace referencia a la imagen allí con la ruta de acceso de Oracle Cloud Infrastructure Container Registry.
Ejecute una prueba desde la máquina local y ejecute el siguiente comando de Fn Project simulando una entrada con los parámetros proporcionados por un formato JSON.
```
echo -n '{"jsonVariable": "value"}' | fn invoke application_function_name function_name
```
Por ejemplo:
```
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
```
Para revisar el archivo creado en el cubo, vaya a Almacenamiento, Almacenamiento de objetos y almacenamiento de archivos, Cubos, haga clic en el cubo y valide que el archivo está presente.

Tarea 4: Creación de un nuevo tema de OCI Notifications y una suscripción Asociación de funciones de OCI como punto final

Crear y utilizar OCI Notifications. Cuando se publica un mensaje en un tema de este servicio, se generará un disparador hacia un punto final. Este punto final será la función creada en la tarea 3.

Vaya a la consola de OCI, vaya a Servicios para desarrolladores, Integración de aplicaciones y Notificaciones. Haga clic en Crear tema e introduzca el nombre de este tema.
Para crear una suscripción para este tema, haga clic en el tema y en Crear suscripción. En este tutorial, seleccionaremos Functions como punto final. Puede seleccionar un punto final como Correo electrónico, Slack, SMS, PagerDuty o URL HTTPS y seleccionar el compartimento de función, la aplicación de Oracle Functions y la función.

Nota: En OCI Notifications, podemos crear varias suscripciones con un punto final diferente si es necesario.
Desde OCI Notifications, podemos publicar un mensaje de formato JSON con las variables necesarias similares a las que hicimos en la tarea 3 para OCI Functions.

Vaya a la consola de OCI, vaya a Servicios para desarrolladores, Integración de aplicaciones y Notificaciones. Haga clic en el tema e introduzca el Mensaje como se muestra en la siguiente imagen.

Para verificar en el cubo, vaya a Almacenamiento, Almacenamiento de objetos y almacenamiento de archivos y Cubos. Haga clic en el cubo y valide si el archivo está presente.

Tarea 5: Creación y configuración de un cluster de Kubernetes en Oracle Cloud Infrastructure Container Engine for Kubernetes

En esta tarea, crearemos un cluster de Kubernetes simple. Para obtener más información, consulte Creación de cluster de OKE.

Vaya a la consola de OCI, vaya a Servicios para desarrolladores, Contenedores y artefactos y haga clic en Clusters de Kubernetes (OKE).
En la página Clusters, haga clic en Crear cluster.
Tenemos dos flujos de trabajo para crear el cluster. Haga clic en Crear personalizado y Enviar.
- Creación rápida: es más fácil, más rápido y despliega automáticamente todos los elementos necesarios para su funcionamiento en OKE, como:
  - Red virtual en la nube (VCN)
  - Gateway de Internet (IG)
  - Gateway de NAT (NAT)
  - Gateway de servicio (SGW)
  - Cluster de Kubernetes
  - Nodos de trabajador y pool de nodos de Kubernetes
- Creación personalizada: para los entornos empresariales, donde ya los clientes tienen servicios, red e infraestructura, es importante personalizar el despliegue de OKE para que sea conforme, esté alineado con la arquitectura del cliente, los recursos y siga las mejores prácticas.
  
  En este tutorial, seleccionaremos Creación personalizada para conservar la arquitectura mostrada anteriormente.
Introduzca el nombre, el compartimento y la versión de Kubernetes del cluster y haga clic en Siguiente.
En la página Configuración de red, introduzca la siguiente información y haga clic en Siguiente.
- Tipo de red: seleccione Red de pods nativos de VCN. Para obtener más información, consulte Red POD.
- VCN: seleccione la VCN.
- Subnets: seleccione una subred pública y privada. En este tutorial, utilizamos la subred pública para el equilibrador de carga y la subred privada para api-endpoint.
En la página Agrupaciones de nodos, introduzca la siguiente información.
- Nombre: introduzca el nombre del pool de nodos.
- Compartment: seleccione el compartimento.
- Tipo de nodo: seleccione el tipo de nodo Gestionado. Para obtener más información, consulte Comparación de nodos virtuales con nodos gestionados.
- Versión: seleccione la versión de Kubernetes.
- Configuración de colocación de nodo:
  - Dominio de disponibilidad: configure el dominio de disponibilidad.
  - Subred de nodo de trabajador: defina la subred privada para los nodos que se crearán en este pool de nodos.
  - Dominio de errores: seleccione los dominios de errores en los que desea distribuir los nodos.
- Unidad e imagen: seleccione una unidad e imagen para nuestros nodos de trabajador.
  - Unidad de nodo: seleccione VM.Standard.E3.Flex Shape (16GB RAM memory and 1 OCPU).
  - Imagen: seleccione la imagen Oracle-Linux-8.9-2024.01.26-0-OKE-1.28.2-679.
- Recuento de nodos: introduzca 1, para este tutorial, basta con 1.
- Volumen de inicio: no modificaremos los parámetros del volumen de inicio.
- Comunicaciones de pod: seleccione una subred privada.
Revise la configuración del cluster de Kubernetes y haga clic en Crear cluster.

Nota: Antes de hacer clic en Crear cluster, asegúrese de que todas las reglas de lista de seguridad de entrada y salida se hayan configurado en cada subred de red de OKE para el equilibrador de carga, el punto final de API y los nodos de trabajador. Para obtener más información, consulte Configuración de recursos de red para despliegue y creación de clusters.

Para verificar el cluster de Kubernetes, vaya a Servicios para desarrolladores, Contenedores y artefactos y Clusters de Kubernetes (OKE).
Para acceder al cluster de Kubernetes, haga clic en el nombre del cluster de Kubernetes y en Acceder al cluster.

Puede ver que el acceso a Cloud Shell está desactivado y que el acceso local está activado, porque cuando seleccionamos la subred de punto final de API, seleccionamos una subred privada, que es más seguro y la única forma de acceder al cluster de Kubernetes es mediante una máquina local, por lo que es exactamente la configuración que estamos utilizando en este tutorial con nuestro host de administración Oracle Linux VM. Seleccione Acceso local.

Nota: Debemos tener instalada la CLI, Docker y kubectl de OCI. Para obtener más información, consulte Installing kubectl.
Una vez que el host de administración esté listo, ejecute el siguiente comando para obtener acceso desde la máquina local al cluster de Kubernetes.
1. Verifique la versión de la CLI de OCI.
```
oci -v
```
2. Cree el directorio kubeconfig en su directorio raíz.
```
mkdir -p $HOME/.kube
```
3. Cree un archivo kubeconfig con un punto final privado nativo 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. Defina la variable de entorno kubeconfig.
```
export KUBECONFIG=$HOME/.kube/config
```
Para verificar el acceso del cluster de Kubernetes, ejecute los comandos de kubectl.
- Obtenga los nodos de trabajador de OKE.
```
kubectl get nodes
```
- Obtenga los pods de OKE.
```
kubectl get pods -A
```

Tarea 6: Desarrollo y despliegue de una aplicación REST de API en Node.js y publicación de mensaje en OCI Notifications

En este tutorial, desarrollaremos y desplegaremos una aplicación REST de API en Node.js para obtener el JSON del cuerpo de solicitud HTTP Post y publicar este cuerpo de JSON como mensaje en OCI Notifications.

Crearemos un proyecto Node.js, crearemos el proyecto, lo enviaremos a Oracle Cloud Infrastructure Container Registry y lo desplegaremos en OKE. Utilizaremos un host de administración de Oracle Linux existente configurado para OCI Functions, por lo que ya hemos instalado Node.js y Docker.

Ejecute los siguientes comandos para crear una carpeta con el nombre de nuestro proyecto en el directorio raíz de la máquina local y cambiar el directorio a la carpeta del proyecto.
```
mkdir api_rest_application_oke
```
```
cd api_rest_application_oke
```
Para inicializar un proyecto, ejecute el siguiente comando y configure el archivo package.json como se muestra en la siguiente imagen.
```
npm init
```
Antes de desarrollar el código Node.js, necesitamos instalar las bibliotecas necesarias para el proyecto.
- La aplicación REST de API debe funcionar como una aplicación web, por lo que necesitaremos una biblioteca express.
```
npm install express
```
- Necesitaremos obtener el cuerpo de JSON de la solicitud HTTP POST; por lo tanto, necesitaremos la biblioteca body-parser.
```
npm install body-parser
```
- La aplicación tendrá que autenticarse con OCI para tener acceso a sus servicios, por lo que necesitaremos la biblioteca oci-common.
```
npm install oci-common
```
- Para publicar un mensaje en OCI Notifications que proviene del cuerpo de la solicitud, necesitaremos la biblioteca oci-ons.
```
npm install oci-ons
```
Nuestro package.json tiene las siguientes dependencias.

Cuando se configura el proyecto Node.js, podemos crear nuestro código en el archivo index.js. El siguiente es el código fuente.

Vamos a autenticarnos en OCI a partir del código mediante el archivo de configuración, de forma similar a la configuración de la CLI de OCI. En ambos casos, las claves y el archivo de configuración se colocan en la carpeta del proyecto de la aplicación REST de API, como se muestra en la siguiente imagen.

Archivo de configuración en proyecto de restauración de 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}`);
});

En la misma carpeta, cree Dockerfile, lo que nos permitirá crear una imagen de contenedor.

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

Cree y transfiera la imagen del proyecto en el repositorio de Docker local.
```
docker build . -t apirestapp:latest
```
Verifique la imagen en el repositorio de Docker local.
```
docker images
```
Nota:
- Debe tener Oracle Cloud Infrastructure Container Registry. Consulte la tarea 3.6.
- Debe estar conectado a Oracle Cloud Infrastructure Container Registry, ya que estamos utilizando el mismo host de administrador de máquina local en el que deberíamos estar conectados. Consulte la tarea 3.7.
Podemos etiquetar la imagen de la aplicación REST de API en Oracle Cloud Infrastructure Container Registry.
```
docker tag apirestapp:latest vcp.ocir.io/idccixxxxx/oke_application/oke_apirest_application_repository:latest
```
Verificar en el repositorio local de Docker.
```
docker images
```
Transfiera la imagen a Oracle Cloud Infrastructure Container Registry.
```
docker push vcp.ocir.io/idccixxxxx/oke_application/oke_apirest_application_repository:latest
```
Para revisar la aplicación de imagen de OKE en Oracle Cloud Infrastructure Container Registry, vaya a Servicios para desarrolladores, Contenedores y artefactos y Container Registry.
Una vez que la imagen se encuentra en Oracle Cloud Infrastructure Container Registry, podemos ir a nuestro host de administración de máquina virtual de Oracle Linux local y desplegar esta imagen en OKE. Para este tutorial, ejecute el siguiente comando para crear el espacio de nombres y el secreto para OKE.
1. Acceda a la carpeta del proyecto.
```
cd api_rest_application_oke/
```
2. Cree un espacio de nombres para OKE.
```
kubectl create namespace ns-tutorial
```
3. Verifique el espacio de nombres.
```
kubectl get namespace ns-tutorial
```
4. Cree un secreto para OKE.
```
kubectl create secret -n ns-tutorial generic ocir --from-file=.dockerconfigjson=../.docker/config.json --type=kubernetes.io/dockerconfigjson
```
5. Verifique el secreto.
```
kubectl get secrets -A
```
Ya tenemos el entorno de OKE listo, por lo que debe desplegar la imagen de aplicación desde Oracle Cloud Infrastructure Container Registry en OKE.

Nota: Para desplegar la imagen de la aplicación, es necesario tener un archivo de manifiesto. En este tutorial, el siguiente archivo yaml es el archivo de manifiesto, se utiliza para desplegar la aplicación y crear el servicio de entrada representado en un equilibrador de carga de OCI que recibe mediante el puerto 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
```
- Ejecute el comando kubectl en la carpeta donde guardó el archivo de manifiesto.
```
kubectl apply -f apirest_application_manifest.yaml
```
  Ahora, la aplicación se despliega y el servicio de equilibrador de carga de entrada se crea en OKE,
- Para validar el pod y el servicio creados en OKE, ejecute el siguiente comando.
```
kubectl get pods -A
```
```
kubectl get svc -A
```
Nota: Descargue el proyecto de la aplicación REST de API desde aquí: api_rest_application_oke.zip.

Tarea 7: Solicitar POST HTTP con cuerpo JSON a la URL expuesta en el equilibrador de carga de la aplicación REST de API

En esta tarea, realizaremos una solicitud HTTP POST con el cuerpo del mensaje JSON del cliente Postman que contenga los datos básicos para crear un archivo en un cubo. Esta solicitud se enviará a la aplicación REST de API en OKE y la transferencia del mensaje en el tema Notificaciones de OCI disparará una función con la lógica para crear un archivo de texto en un cubo específico, como se muestra en la arquitectura de Introducción.

Para instalar Postman, consulte Postman Installation.
Abra la aplicación Postman.
1. Haga clic en el menú de hamburguesa, Archivo y seleccione Nuevo.
2. Seleccione HTTP.
3. Introduzca la URL expuesta por la aplicación REST de API desplegada en OKE: http://"IP ADDRESS LOAD BALANCER"/api/receive-json y seleccione el método POST. En la etiqueta Cuerpo, seleccione crudo e introduzca el mensaje JSON en el campo en blanco.
Haga clic en Enviar para enviar la solicitud.

Para verificar el archivo creado en el cubo específico de OCI Object Storage, vaya a Storage, Object Storage & Archive Storage y Buckets y haga clic en el cubo.

En este tutorial, ha utilizado OCI Notifications con un nuevo caso de uso, integrando varios servicios como API, SDK de OCI, aplicaciones de Kubernetes desplegadas en OKE, OCI Functions y OCI Object Storage.

Agradecimientos

Autor: Iván Alexander Vásquez Chinome (Especialista en soluciones en la nube de equipo A de Oracle LAD)

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de aprendizaje gratuito en el canal YouTube de Oracle Learning. Además, visite education.oracle.com/learning-explorer para convertirse en Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.

Título e Información de Copyright

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

F96547-01

April 2024

Oracle y/o sus filiales.