Observação:

Este tutorial requer acesso ao Oracle Cloud. Para se cadastrar em uma conta gratuita, consulte Conceitos básicos do Oracle Cloud Infrastructure Free Tier.
Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Publicar uma Mensagem no OCI Notifications, Disparar uma Função e Criar um Arquivo no Bucket do OCI Object Storage

Introdução

Você pode configurar um serviço de assinatura de publicação, como o Oracle Cloud Infrastructure (OCI), Notifications, que envia mensagens para pontos finais que podem alertar, executar ações por meio de assinatura configurada; não apenas oferecendo suporte ao uso do Oracle Cloud Infrastructure Monitoring ou do OCI Connector Hub casos, mas também os eventos podem ser gerados dos aplicativos clientes, mensagens de API que devem representar uma ação imediata a ser executada quando o aplicativo envia uma mensagem quando um evento aciona o OCI Notifications.

A arquitetura pode ser mais ou menos complexa, mas para esse caso de uso o cliente faz uma solicitação HTTP POST, enviando no corpo um JSON que tenha determinados atributos para criar um arquivo, como nome do arquivo, nome do bucket no qual você deseja criar o arquivo no OCI Object Storage e a mensagem que estará dentro do arquivo.

Em seguida, o aplicativo REST de API implantado no Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) e desenvolvido em Node.js obtém o JSON do corpo da solicitação e também neste aplicativo, as bibliotecas do OCI são usadas para publicar uma mensagem no OCI Notifications que já tem uma função Node.js assinada e desenvolvida para criar o arquivo de texto em um bucket específico no OCI Object Storage com os parâmetros JSON enviados.

Arquitetura do OCI

Arquitetura do OCI

Arquitetura de Caso de Uso

Arquitetura de Caso de Uso

Neste tutorial, começaremos a configurar a partir do último serviço até chegarmos ao primeiro no Oracle Cloud Infrastructure (OCI):

OCI Object Storage
OCI Functions
Notificações do OCI
Oracle Cloud Infrastructure Container Engine for Kubernetes

Objetivos

Crie um novo bucket do OCI Object Storage.
Configurar e criar o OCI Functions.
Configure, desenvolva e envie o OCI Functions usando o Kit de Desenvolvimento de Funções (FDK) Node.js para criar um novo arquivo de texto em um bucket específico com base em parâmetros JSON.
Crie um novo tópico no OCI Notifications e crie uma assinatura associando um OCI Functions como ponto final.
Crie e configure um cluster do Kubernetes no OKE.
Desenvolva e implante um aplicativo REST de API em Node.js para obter o JSON do corpo da solicitação HTTP POST e publique esse corpo JSON como uma mensagem no OCI Notifications.
Solicite o HTTP POST com um corpo JSON para o URL exposto no balanceador de carga do aplicativo REST da API.

Pré-requisitos

Acesso a um tenant do OCI. Para criar uma conta do Oracle Cloud grátis, consulte Criar uma Conta do Oracle Cloud Grátis.
Instale a Interface de Linha de Comando (CLI) do OCI. Para obter mais informações, consulte Instalando a CLI do OCI.
Crie uma VCN com sub-redes públicas e privadas. Para obter mais informações, consulte Criando uma VCN e Criando uma Sub-rede.
Crie uma tabela de roteamento para tráfego de acesso à internet com o gateway de internet. Para obter mais informações, consulte Tabela de Roteamento de VCN e Gateway de Internet.
Crie um compartimento no qual você possa agrupar seus serviços do OCI. Para obter mais informações, consulte Criando um Compartimento.

Tarefa 1: Criar um Bucket no OCI Object Storage

Faça log-in na Console do OCI, navegue até Armazenamento, Armazenamento de Objetos e Armazenamento de Arquivos Compactados, Buckets e selecione o Compartimento de sua preferência.
Clique em Criar Bucket e especifique as seguintes informações.
- Nome do Bucket: Digite o nome do bucket. Por exemplo, data ou outro nome.
- Default Storage Tier: Para este tutorial, selecione Standard.
- Encryption: Selecione Criptografar usando chaves gerenciadas pela Oracle.
- Log de recursos: Selecione Log de recursos ativado para ter observabilidade sobre o que está acontecendo no bucket.

Tarefa 2: Configurar e Criar um OCI Functions

Vá para a Console do OCI, navegue até Developer Services, Functions, Applications e selecione Compartment.
Clique em Criar aplicativo e insira as seguintes informações.
- Nome: Informe o nome do seu aplicativo de função.
- VCN: Selecione a VCN criada nos pré-requisitos.
- Sub-redes: Selecione a sub-rede criada nos pré-requisitos. Neste tutorial, configuramos uma sub-rede pública.
- Forma: Selecione a forma relacionada ao processador suportado por este aplicativo. Para este tutorial, é GENERIC_X86.
Ative os logs para rastrear a execução e ver erros do aplicativo OCI Functions, portanto, nos detalhes do aplicativo de função, em Recursos, clique em Logs e selecione Ativar Log configurando o compartimento, o Grupo de Logs, o Nome do Log e o horário da Retenção de Log.

Tarefa 3: Configurar, Desenvolver e Enviar Funções do OCI usando o FDK Node.js para Criar um novo Arquivo de Texto

Configure, desenvolva e envie um OCI Functions usando FDK Node.js para criar um novo arquivo de texto em um bucket específico com base em parâmetros JSON.

Observação: Configure seu cliente como: Desktop, PC, Laptop ou Máquina Virtual (VM) e o contexto de sua função em que você trabalhará com o Fn Project, porque o OCI Functions é alimentado pelo mecanismo de código-fonte aberto do Fn Project para executar operações de criação, leitura, atualização e exclusão no OCI Functions.

Usaremos uma VM (host administrativo) do Oracle Linux 8 na OCI, conforme visto na arquitetura em Introdução.

Vá para a Console do OCI, navegue até Developer Services, Functions, Applications e clique em seu aplicativo de função.
Na seção Recursos, clique em Introdução e selecione Configuração local para usar uma VM externa do Oracle Linux.
Observação: você deve ter instalado os seguintes componentes.
- CLI ( Interface de Linha de Comando ). do OCI
- Node.js no Oracle Linux.
  sudo yum update sudo yum install -y nodejs node --version
  A versão do Node.js deve ser suportada pelo OCI FDK Functions.
  
  Se a versão não for suportada, é necessário executar os comandos a seguir.
  
  Exemplo:
  sudo yum module reset nodejs sudo yum module enable nodejs:18 sudo yum module install nodejs
- CLI do Fn Project instalada em sua VM. Para obter mais informações, consulte Instalando a CLI do Fn Project.
Crie seu projeto na linguagem de programação desejada. Neste tutorial, usaremos Node.js. Para criar um novo projeto, execute o comando a seguir.
```
fn init --runtime node "Name_Of_Your_Project"
```
Exemplo:
```
fn init --runtime node app_mess_createFile_os_function
```
Para acessar a pasta do projeto, execute o comando a seguir.
```
cd "Name_Of_Your_Project"/
```
Exemplo:
```
cd app_mess_createFile_os_function/
```

Crie e atualize um contexto específico para nosso compartimento e o URL da API do Oracle Functions para sua região que é especificado em Conceitos Básicos.

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"

Exemplo:

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

Informe o caminho do Oracle Cloud Infrastructure Container Registry no qual a imagem do aplicativo será enviada.
Observação: Se você não tiver o Oracle Cloud Infrastructure Container Registry, crie esse repositório para enviar a imagem da função.
1. Vá para Developer Services, Containers & Artifacts, Container Registry e clique em Criar repositório.
2. Especifique as seguintes informações e clique em Criar.
  - Criar no Compartimento: Selecione seu compartimento,
  - Acesso: Selecione Público.
  - nome do repositório: informe o nome do repositório.
Depois de ter certeza de que o Oracle Cloud Infrastructure Container Registry foi criado, defina o caminho desse repositório até o prefixo no contexto.
```
fn update context registry "regionID.ocir.io/tenancy_namespace/[repo-name-prefix]"
```
Exemplo:
```
fn update context registry vcp.ocir.io/idccixxxxx/apigwrepo
```
Acesse o Oracle Cloud Infrastructure Container Registry.
Observação: para fazer log-in, criar, extrair e enviar imagens para o repositório, você deve ter:
- Docker instalado. Para obter mais informações, consulte Como instalar o Docker no Oracle Linux 8/7.
- Nome de usuário e um token de autenticação do Oracle Cloud Infrastructure criados. Para obter mais informações, consulte Como Obter um Token de Autenticação.
Execute o comando a seguir para fazer log-in no Oracle Cloud Infrastructure Container Registry.
```
sudo docker login -u 'tenancy_namespace/username' regionID.ocir.io
```
```
Password: xxxxxx
```
Exemplo (Para este exemplo, o nome de usuário é federado com o Oracle Identity Cloud Service; portanto, ele deve ser incluído):
```
sudo docker login -u 'idccixxxxx/OracleIdentityCloudService/ivan.v.vasquez@oracle.com' vcp.ocir.io
```
```
Password: xxxxxx
```

Depois de configurar o OCI Functions, desenvolveremos o programa Node.js para criar um arquivo de texto em um bucket específico.

Criamos o projeto de função na Tarefa 3.3, ele cria os seguintes arquivos na pasta do projeto:

func.js (Neste arquivo, gravamos a lógica do projeto node.js).
func.yaml (Este é o arquivo de configuração da função).
package.json (Esse arquivo especifica as dependências Node.js necessárias para a lógica do projeto).

Neste projeto, precisaremos adicionar as seguintes dependências do OCI SDK Node.js; oci-objectstorage e oci-common. Execute o comando a seguir para instalar dependências.

npm install oci-common

Adicionando Dependência oci-common

npm install oci-objectstorage

Adicionando oci-objectstorage de Dependência

Podemos ver as dependências adicionadas no arquivo package.json.

Dependências adicionadas

Vamos autenticar no OCI a partir do código usando o arquivo de configuração, semelhante ao processo de configuração da CLI do OCI em que as chaves e o arquivo de configuração foram colocados na pasta Fn Project.

Pasta do Projeto da Função

Veja a seguir o código-fonte Node.js, e o detalhe de cada fragmento de código é explicado com comentários.

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

Observação: Faça download do Projeto do OCI Functions aqui: app_mess_createFile_os_function.zip.

O projeto foi criado. Certifique-se de permanecer conectado ao Oracle Cloud Infrastructure Container Registry. Criaremos e enviaremos a imagem no Oracle Cloud Infrastructure Container Registry e implantaremos essa função no aplicativo OCI Functions.
1. Vá para a Console do OCI, navegue até Developer Services, Functions, Applications e clique em seu aplicativo de função.
  
  Em nossa máquina local, devemos estar na pasta do projeto do OCI Functions.
```
fn deploy --app name_of_your_function_application
```
  Exemplo:
```
fn deploy --app fn-demo-apgw
```
2. Para validar se a imagem foi implantada no Oracle Cloud Infrastructure Container Registry, vá para a Console do OCI e navegue até Developer Services, Containers & Artifacts e Container Registry.
  
  Para verificar se a função está implantada no aplicativo OCI Functions, vá para a Console do OCI e navegue até Serviços do Desenvolvedor, Funções, Aplicativos, clique em seu aplicativo de função e veja se a imagem é referenciada lá com o caminho do Oracle Cloud Infrastructure Container Registry.
Execute um teste em sua máquina local, execute o seguinte comando Fn Project simulando uma entrada com os parâmetros fornecidos por um formato JSON.
```
echo -n '{"jsonVariable": "value"}' | fn invoke application_function_name function_name
```
Exemplo:
```
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 o arquivo criado no bucket, vá para Armazenamento, Armazenamento de Objetos e Armazenamento de Arquivos Compactados, Buckets, clique no bucket e valide se o arquivo está presente.

Tarefa 4: Criar um novo Tópico de Notificações do OCI e uma Assinatura Associando um OCI Functions como Ponto Final

Crie e utilize o OCI Notifications. Quando uma mensagem é publicada em um tópico dentro deste serviço, ela gera um trigger para um ponto final. Este ponto final será a função criada na Tarefa 3.

Vá para a Console do OCI, navegue até Developer Services, Application Integration e Notifications. Clique em Criar Tópico e digite o nome desse tópico.
Para criar uma assinatura para este tópico, clique em seu tópico e em Criar Assinatura. Neste tutorial, selecionaremos Functions como ponto final. Você pode selecionar um ponto final como E-mail, Slack, SMS, PagerDuty ou URL HTTPS e selecionar o Compartimento de funções, o Aplicativo Oracle Functions e o Function.

Observação: no OCI Notifications, podemos criar várias assinaturas com outro ponto final, se necessário.
No OCI Notifications, podemos publicar uma mensagem de formato JSON com as variáveis necessárias semelhantes ao que fizemos na Tarefa 3 do OCI Functions.

Vá para a Console do OCI, navegue até Developer Services, Application Integration e Notifications. Clique no tópico e informe a Mensagem conforme mostrado na imagem a seguir.

Para verificar no seu bucket, vá para Armazenamento, Armazenamento de Objetos e Armazenamento de Arquivos Compactados e Buckets. Clique no bucket e valide se o arquivo está presente.

Tarefa 5: Criar e Configurar um Cluster do Kubernetes no Oracle Cloud Infrastructure Container Engine for Kubernetes

Nesta tarefa, criaremos um cluster simples do Kubernetes. Para obter mais informações, consulte Criação de Cluster do OKE.

Vá para a Console do OCI, navegue até Serviços ao Desenvolvedor, Contêineres e Artefatos e clique em Clusters do Kubernetes (OKE).
Na página Clusters, clique em Criar cluster.
Temos dois fluxos de trabalho para criar o cluster. Clique em Criação personalizada e em Enviar.
- Criação Rápida: Isso é mais fácil, rápido e implanta automaticamente todos os elementos exigidos pelo OKE para sua operação, como:
  - Rede Virtual na Nuvem (VCN)
  - Gateway de Internet (IG)
  - Gateway NAT (NAT)
  - Gateway de Serviço (SGW)
  - Cluster do Kubernetes
  - Nó(s) de trabalho do Kubernetes e pool de nós
- Criação personalizada: Para os ambientes corporativos, em que já os clientes têm serviços, rede, infraestrutura, é importante personalizar a implantação do OKE para estar em conformidade, alinhado com a arquitetura do cliente, os recursos e seguindo as melhores práticas.
  
  Neste tutorial, selecionaremos Criação Personalizada para preservar nossa arquitetura mostrada acima.
Informe o Nome, o Compartimento, a versão do Kubernetes do cluster e clique em Próximo.
Na página Configuração da rede, digite as informações a seguir e clique em Próximo.
- Tipo de Rede: Selecione Rede de pod nativo da VCN. Para obter mais informações, consulte Rede de POD.
- VCN: Selecione sua VCN.
- Sub-redes: Selecione sub-rede privada e pública. Neste tutorial, usamos sub-rede pública para balanceador de carga e sub-rede privada para api-endpoint.
Na página Pools de nós, digite as informações a seguir.
- Nome: Digite o nome do pool de nós.
- Compartimento: Selecione seu compartimento.
- Tipo de nó: Selecione o tipo de nó Gerenciado. Para obter mais informações, consulte Comparando Nós Virtuais com Nós Gerenciados.
- Versão: Selecione a versão do Kubernetes.
- Configuração de Posicionamento de Nó:
  - Domínio de disponibilidade: Configure o domínio de disponibilidade.
  - Sub-rede do nó de trabalho: Defina a sub-rede privada para os nós que serão criados nesse pool de nós.
  - Domínio de falha: Selecione os domínios de falha nos quais você deseja que os nós sejam distribuídos.
- Forma e imagem: Selecione uma forma e uma imagem para nossos nós de trabalho,
  - Forma do nó: Selecione VM.Standard.E3.Flex Shape (16GB RAM memory and 1 OCPU).
  - Imagem: Selecione a imagem Oracle-Linux-8.9-2024.01.26-0-OKE-1.28.2-679.
- Contagem de nós: Informe 1. Para este tutorial, 1 é suficiente.
- Volume de inicialização: Não modificaremos os parâmetros do volume de inicialização.
- Comunicações de pod: Selecione a sub-rede privada.
Verifique a configuração do cluster do Kubernetes e clique em Criar cluster.

Observação: Antes de clicar em Criar cluster, certifique-se de que todas as regras da lista de segurança de entrada e saída tenham sido configuradas em cada sub-rede de rede do OKE para balanceador de carga, ponto final de API e nós de trabalho. Para obter mais informações, consulte Configuração do Recurso de Rede para Criação e Implantação de Cluster.

Para verificar o cluster do Kubernetes, navegue até Developer Services, Containers & Artifacts e Clusters do Kubernetes (OKE).
Para acessar o cluster Kubernetes, clique no nome do cluster Kubernetes e em Acessar Cluster.

Você pode ver que o Acesso ao Cloud Shell está desativado e o Acesso Local está ativado, porque quando selecionamos a sub-rede do ponto final da API, escolhemos uma sub-rede privada, que é mais seguro e a única maneira de acessar o cluster do Kubernetes é usando uma máquina local, por isso é exatamente a configuração que estamos usando neste tutorial com nosso host admin Oracle Linux VM. Selecione Acesso Local.

Observação: Devemos ter instalado a CLI do OCI, o Docker e o kubectl. Para obter mais informações, consulte Instalando o kubectl.
Quando o host de administrador estiver pronto, execute o comando a seguir para obter acesso da sua máquina local ao cluster do Kubernetes.
1. Verifique a versão da CLI do OCI.
```
oci -v
```
2. Crie o diretório kubeconfig em seu home.
```
mkdir -p $HOME/.kube
```
3. Crie um arquivo kubeconfig com um ponto final privado nativo da 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 a variável de ambiente kubeconfig.
```
export KUBECONFIG=$HOME/.kube/config
```
Para verificar o acesso do cluster do Kubernetes, execute comandos kubectl.
- Obtenha os nós de trabalho do OKE.
```
kubectl get nodes
```
- Obtenha os pods do OKE.
```
kubectl get pods -A
```

Tarefa 6: Desenvolver e Implantar um Aplicativo REST de API em Node.js e Publicar Mensagem no OCI Notifications

Neste tutorial, desenvolveremos e implantaremos um Aplicativo REST de API em Node.js para obter o JSON do corpo da solicitação HTTP Post e publicar esse corpo JSON como uma mensagem no OCI Notifications.

Criaremos um projeto Node.js, criaremos o projeto, o enviaremos ao Oracle Cloud Infrastructure Container Registry e o implantaremos no OKE. Usaremos um host de administração existente do Oracle Linux configurado para o OCI Functions para que já tenhamos instalado o Node.js e o Docker.

Execute os comandos a seguir para criar uma pasta com o nome do nosso projeto no home da máquina local e altere o diretório para a pasta do projeto.
```
mkdir api_rest_application_oke
```
```
cd api_rest_application_oke
```
Para inicializar um projeto, execute o comando a seguir e configure o arquivo package.json conforme mostrado na imagem a seguir.
```
npm init
```
Antes de desenvolver o código Node.js, precisamos instalar as bibliotecas necessárias para o projeto.
- O aplicativo REST da API precisa funcionar como um aplicativo web, portanto, precisaremos da biblioteca express.
```
npm install express
```
- Precisaremos obter o corpo JSON da solicitação HTTP POST; portanto, precisaremos da biblioteca body-parser.
```
npm install body-parser
```
- O aplicativo precisará ser autenticado com o OCI para ter acesso a seus serviços; portanto, precisaremos da biblioteca oci-common.
```
npm install oci-common
```
- Para publicar uma mensagem no OCI Notifications proveniente do corpo da solicitação, precisaremos da biblioteca oci-ons.
```
npm install oci-ons
```
Nosso package.json tem as dependências a seguir.

Quando o projeto Node.js é configurado, podemos criar nosso código no arquivo index.js. Veja a seguir o código de origem.

Vamos autenticar no OCI a partir do código usando o arquivo de configuração, semelhante à forma como configuramos a CLI do OCI. Em ambos os casos, as chaves e o arquivo de configuração são colocados na pasta do projeto do aplicativo REST da API, conforme mostrado na imagem a seguir.

Arquivo de configuração no Projeto Rest da 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}`);
});

Na mesma pasta, crie Dockerfile, o que nos permitirá criar uma imagem de contêiner.

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

Crie e envie a imagem do projeto no repositório local do Docker.
```
docker build . -t apirestapp:latest
```
Verifique a imagem no repositório local do Docker.
```
docker images
```
Observação:
- Você deve ter o Oracle Cloud Infrastructure Container Registry. Consulte a Tarefa 3.6.
- Você deve estar conectado ao Oracle Cloud Infrastructure Container Registry, pois estamos usando o mesmo host de administrador de máquina local em que devemos estar conectados. Consulte a Tarefa 3.7.
Podemos marcar com tag a imagem do aplicativo REST da API no Oracle Cloud Infrastructure Container Registry.
```
docker tag apirestapp:latest vcp.ocir.io/idccixxxxx/oke_application/oke_apirest_application_repository:latest
```
Verifique no repositório local do Docker.
```
docker images
```
Envie a imagem ao Oracle Cloud Infrastructure Container Registry.
```
docker push vcp.ocir.io/idccixxxxx/oke_application/oke_apirest_application_repository:latest
```
Para revisar o aplicativo de imagem do OKE no Oracle Cloud Infrastructure Container Registry, vá para Developer Services, Containers & Artifacts e Container Registry.
Assim que a imagem estiver no Registro de Contêiner do Oracle Cloud Infrastructure, poderemos acessar nosso host de administração de VM local do Oracle Linux e implantar essa imagem no OKE. Para este tutorial, execute o comando a seguir para criar o namespace e o segredo do OKE.
1. Acesse a pasta do projeto.
```
cd api_rest_application_oke/
```
2. Crie um namespace para o OKE.
```
kubectl create namespace ns-tutorial
```
3. Verifique o namespace.
```
kubectl get namespace ns-tutorial
```
4. Criar segredo para o OKE.
```
kubectl create secret -n ns-tutorial generic ocir --from-file=.dockerconfigjson=../.docker/config.json --type=kubernetes.io/dockerconfigjson
```
5. Verifique o segredo.
```
kubectl get secrets -A
```
Já temos o ambiente OKE pronto para implantar a imagem do aplicativo do Oracle Cloud Infrastructure Container Registry no OKE.

Observação: para implantar a imagem do aplicativo, é necessário ter um arquivo de manifesto. Neste tutorial, o arquivo yaml a seguir é o arquivo de manifesto, ele é usado para implantar o aplicativo e criar o serviço de entrada representado em um Balanceador de Carga do OCI que está fazendo listening usando a 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
```
- Execute o comando kubectl na pasta em que salvou o arquivo de manifesto.
```
kubectl apply -f apirest_application_manifest.yaml
```
  Agora, o aplicativo é implantado e o serviço do balanceador de carga de entrada é criado no OKE,
- Para validar o pod e o serviço criados no OKE, execute o comando a seguir.
```
kubectl get pods -A
```
```
kubectl get svc -A
```
Observação: Faça download do projeto de Aplicativo REST da API aqui: api_rest_application_oke.zip.

Tarefa 7: Solicitar POST HTTP com corpo JSON para o URL exposto no Balanceador de Carga do Aplicativo REST da API

Nesta tarefa, faremos uma solicitação HTTP POST com o corpo da mensagem JSON do cliente Postman que contém os dados básicos para criar um arquivo em um bucket. Essa solicitação será enviada ao aplicativo REST de API no OKE e o envio da mensagem no tópico Notificações do OCI acionará uma função com a lógica para criar um arquivo de texto em um bucket específico, conforme ilustrado na arquitetura em Introdução.

Para instalar o Postman, consulte Instalação do Postman.
Abra o aplicativo Postman.
1. Clique no menu de hambúrguer, Arquivo e selecione Novo.
2. Selecione HTTP.
3. Informe o URL exposto pelo aplicativo REST de API implantado no OKE: http://"IP ADDRESS LOAD BALANCER"/api/receive-json e selecione o método POST. Na tag Body, selecione raw e digite a mensagem JSON no campo em branco.
Clique em Enviar para enviar a solicitação.

Para verificar o arquivo criado no bucket específico no OCI Object Storage, vá para Storage, Object Storage & Archive Storage, Buckets e clique em seu bucket.

Neste tutorial, você usou o OCI Notifications com um novo caso de uso, integrando vários serviços, como APIs, OCI SDK, aplicativos Kubernetes implantados no OKE, OCI Functions e OCI Object Storage.

Confirmação

Autor - Iván Alexander Vásquez Chinome (Especialista em Soluções do Oracle LAD A-Team Cloud)

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

Título e Informações de Copyright

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

F96553-01

April 2024

Oracle e/ou suas empresas afiliadas.