注意：

• 此教程需要访问 Oracle Cloud。要注册免费账户，请参阅开始使用 Oracle Cloud Infrastructure Free Tier 。
• 它使用 Oracle Cloud Infrastructure 身份证明、租户和区间示例值。完成实验室时，请将这些值替换为特定于您的云环境的值。

在 OCI 通知中发布消息，触发函数并在 OCI 对象存储存储桶中创建文件

简介

您可以配置发布订阅服务，例如 Oracle Cloud Infrastructure (OCI) 通知，将消息推送到可以发出警报的端点，通过配置的订阅采取措施；不仅支持 Oracle Cloud Infrastructure Monitoring 或 OCI Connector Hub 使用 case，但也可以从客户应用程序生成事件，API 消息必须表示当应用程序在事件触发 OCI 通知时发送消息时立即执行的操作。

架构可能或多或少是复杂的，但对于此用例，客户端会发出 HTTP POST 请求，在正文中发送具有特定属性的 JSON 创建文件，例如文件名、要在 OCI 对象存储中创建文件的存储桶名称，以及文件中将显示的消息。

然后，部署在 Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) 中的 API REST 应用（在 Node.js 中开发）从请求正文获取 JSON，在此应用中，OCI 库用于在 OCI 通知中发布消息，该消息已订阅并开发 Node.js 函数，用于在 OCI 对象存储的特定存储桶中创建文本文件并发送 JSON 参数。

OCI 体系结构

使用案例体系结构

在本教程中，我们将从最后一个服务开始配置，直到到达 Oracle Cloud Infrastructure (OCI) 中的第一个服务为止：

• OCI 对象存储

• OCI 函数

• OCI 通知

• 适用于 Kubernetes 的 Oracle Cloud Infrastructure 容器引擎

目标

• 创建新的 OCI 对象存储桶。

• 配置和创建 OCI 函数。

• 使用函数开发工具包 (FDK) Node.js 配置、开发和推送 OCI 函数，以便根据 JSON 参数在特定存储桶中创建新的文本文件。

• 在 OCI 通知中创建新主题并创建将 OCI 函数关联为端点的订阅。

• 在 OKE 中创建和配置 Kubernetes 集群。

• 在 Node.js 中开发和部署 API REST 应用，以从 HTTP POST 请求正文获取 JSON，并在 OCI 通知中将此 JSON 正文作为消息发布。

• 将具有 JSON 正文的 HTTP POST 请求到在 API REST 应用程序的负载平衡器中公开的 URL。

先决条件

• 访问 OCI 租户。要创建免费的 Oracle Cloud 账户，请参阅创建免费的 Oracle Cloud 账户。

• 安装 OCI Command Line Interface (CLI)。有关详细信息，请参阅安装 OCI CLI 。

• 使用公共和专用子网创建 VCN。有关详细信息，请参阅创建 VCN 和创建子网。

• 为通过 Internet 网关的 Internet 访问流量创建路由表。有关详细信息，请参阅 VCN 路由表和互联网网关。

• 创建可对 OCI 服务进行分组的区间。有关详细信息，请参阅创建区间。

任务 1：在 OCI 对象存储中创建存储桶

1. 登录到 OCI 控制台，导航到存储、对象存储和归档存储、存储桶，然后选择首选项的区间。

2. 单击创建存储桶并输入以下信息。

   • 组名称：输入组的名称。例如，data 或其他名称。
   • 默认存储层：对于本教程，选择标准。
   • 加密：选择 Encrypt using Oracle managed keys 。
   • 资源日志记录：选择启用资源日志记录可监视存储桶中正在发生的情况。

   

任务 2：配置和创建 OCI 函数

1. 转到 OCI 控制台，导航到开发人员服务、函数、应用程序，然后选择区间。

2. 单击创建应用程序并输入以下信息。

   • 名称：输入函数应用程序的名称。
   • VCN：选择在先决条件中创建的 VCN。
   • 子网：选择在先决条件中创建的子网。在本教程中，我们配置了一个公共子网。
   • 配置：选择与此应用程序支持的处理器相关的配置。对于本教程，它是 GENERIC_X86。

   

3. 启用日志以跟踪 OCI Functions 应用程序的执行并查看错误，因此在函数应用程序的详细信息中，在资源下，单击日志并选择启用日志以配置区间、日志组、日志名称和日志保留的时间。

   

任务 3：使用 FDK Node.js 配置、开发和推送 OCI 函数以创建新文本文件

使用 FDK Node.js 配置、开发和推送 OCI 函数，以基于 JSON 参数在特定存储桶中创建新文本文件。

注：配置您的客户端，例如桌面、PC、笔记本电脑或虚拟机 (VM) 以及您将在其中使用 Fn 项目的函数上下文，因为 OCI 函数由 Fn 项目开源引擎提供支持，以便对 OCI 函数执行创建、读取、更新和删除操作。

我们将在 OCI 中使用 Oracle Linux 8 VM（管理主机），如“简介”中的架构所示。

1. 转到 OCI 控制台，导航到开发人员服务、函数、应用程序并单击函数应用程序。

2. 在 Resources（资源）部分下，单击 Getting started（入门），然后选择 Local setup（本地设置）以使用外部 Oracle Linux VM。

   

   注：您必须已安装以下组件。

   • OCI Command Line Interface (CLI)。

   • Oracle Linux 中的 Node.js。

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

     OCI FDK Functions 必须支持 Node.js 版本。

     

     如果不支持该版本，则需要执行以下命令。

     示例：

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

   • VM 中安装的 Fn 项目 CLI。有关更多信息，请参见 Installing the Fn Project CLI 。

3. 使用所需的编程语言创建项目。在本教程中，我们将使用 Node.js。要创建新项目，请运行以下命令。

   fn init --runtime node "Name_Of_Your_Project"
   

   示例：

   fn init --runtime node app_mess_createFile_os_function
   

4. 要访问项目文件夹，请运行以下命令。

   cd "Name_Of_Your_Project"/
   

   示例：

   cd app_mess_createFile_os_function/
   

5. 为我们的区间创建和更新特定上下文，并为您的区域创建和更新 Oracle Functions API URL（在入门中指定）。

   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"
   

   示例：

   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. 输入将推送应用程序映像的 Oracle Cloud Infrastructure 容器注册表的路径。

   注：如果您没有 Oracle Cloud Infrastructure 容器注册表，则必须创建此资料档案库以推送函数映像。

   1. 转到开发人员服务、容器和对象、容器注册表，然后单击创建资料档案库。

   2. 输入以下信息并单击创建。

      • 在区间中创建：选择您的区间，
      • 访问权限：选择公共。
      • 系统信息库名称：输入系统信息库名称。

      

   确定已创建 Oracle Cloud Infrastructure 容器注册表后，请设置此资料档案库的路径，直到上下文中的前缀。

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

   示例：

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

7. 登录到 Oracle Cloud Infrastructure 容器注册表。

   注：要登录、构建、拉取映像并将其推送到资料档案库，您必须具有：

   • 已安装 Docker。有关更多信息，请参见 How to install Docker on Oracle Linux 8/7 。

   • 已创建 Oracle Cloud Infrastructure 用户名和验证令牌。有关详细信息，请参阅获取验证令牌。

   运行以下命令以登录到 Oracle Cloud Infrastructure 容器注册表。

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

   Password: xxxxxx
   

   示例（在本例中，用户名与 Oracle Identity Cloud Service 联合，因此必须包括该用户名）：

   sudo docker login -u 'idccixxxxx/OracleIdentityCloudService/[e-mail]' vcp.ocir.io
   

   Password: xxxxxx
   

   

8. 配置 OCI 函数后，我们将开发 Node.js 程序以在特定存储桶中创建文本文件。

   我们在任务 3.3 中创建了函数项目，它会在项目文件夹中创建以下文件：

   • func.js（在此文件中，我们编写 node.js 项目逻辑）。
   • func.yaml（这是函数配置文件）。
   • package.json（此文件指定项目逻辑所需的 Node.js 相关项）。

   在此项目中，我们将需要添加以下 Node.js OCI SDK 相关项： oci-objectstorage 和 oci-common 。运行以下命令安装依赖项。

   npm install oci-common
   

   

   npm install oci-objectstorage
   

   

   我们可以看到在 package.json 文件中添加的依赖项。

   

   我们将在 OCI 中使用配置文件从代码进行验证，类似于配置 OCI CLI 的过程，其中密钥和配置文件都放置在 Fn Project 文件夹中。

   

   下面是 Node.js 源代码，每个代码片段的详细信息都附有注释。

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

   注：请从此处下载 OCI 函数项目：app_mess_createFile_os_function.zip 。

9. 项目已创建，请确保您始终登录 Oracle Cloud Infrastructure 容器注册表。我们将在 Oracle Cloud Infrastructure 容器注册表中构建和推送映像，并在 OCI Functions 应用程序中部署此功能。

   1. 转到 OCI 控制台，导航到开发人员服务、函数、应用程序并单击函数应用程序。

      在本地计算机上，我们必须在 OCI Functions 项目文件夹中。

      fn deploy --app name_of_your_function_application
      

      示例：

      fn deploy --app fn-demo-apgw
      

      

   2. 要验证映像是否已部署在 Oracle Cloud Infrastructure 容器注册表中，请转到 OCI 控制台，然后导航到开发人员服务、容器和对象以及容器注册表。

      

      要检查该函数是否部署在 OCI Functions 应用程序中，请转到 OCI 控制台并导航到开发人员服务、函数、应用程序，单击您的函数应用程序，然后查看该映像是否通过 Oracle Cloud Infrastructure 容器注册表路径引用。

      

10. 从本地计算机运行测试，执行以下 Fn Project 命令，使用 JSON 格式提供的参数模拟输入。

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

    示例：

    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
    

    

    要查看在存储桶中创建的文件，请转至存储、对象存储和归档存储、存储桶，然后单击您的存储桶并验证文件是否存在。

    

    

任务 4：创建新的 OCI 通知主题和将 OCI 函数关联为端点的订阅

1. 创建和使用 OCI 通知。在此服务内的主题中发布消息时，将针对端点生成触发器。此端点是在任务 3 中创建的函数。

   转到 OCI 控制台，导航到开发人员服务、应用集成和通知。单击创建主题并输入此主题的名称。

   

   

2. 要为此主题创建订阅，请单击您的主题并创建订阅。在本教程中，我们将选择 Functions 作为端点。您可以选择电子邮件、Slack、SMS、PagerDuty 或 HTTPS URL 等端点，然后选择函数区间、Oracle Functions 应用程序和函数。

   

   

   注：在 OCI 通知中，如果需要，我们可以使用不同的端点创建多个订阅。

3. 在 OCI 通知中，我们可以发布 JSON 格式消息，其中包含必需的变量，类似于我们在 OCI Functions 的任务 3 中所做的变量。

   转到 OCI 控制台，导航到开发人员服务、应用集成和通知。单击主题并输入消息，如下图中所示。

   

   要在存储桶中验证，请转至存储、对象存储和归档存储和存储桶。单击存储桶并验证文件是否存在。

   

   

任务 5：在 Oracle Cloud Infrastructure Container Engine for Kubernetes 中创建和配置 Kubernetes 集群

在此任务中，我们将创建一个简单的 Kubernetes 集群。有关更多信息，请参见 Creation of OKE Cluster 。

1. 转到 OCI 控制台，导航到开发人员服务、容器和对象，然后单击 Kubernetes 集群 (OKE) 。

2. 在集群页中，单击创建集群。

3. 我们有两个工作流来创建集群。单击自定义创建和提交。

   • 快速创建：这更容易、更快，并自动部署 OKE 操作所需的所有元素，例如：

     • Virtual Cloud Network (VCN)
     • Internet 网关 (IG)
     • NAT 网关 (NAT)
     • 服务网关 (SGW)
     • Kubernetes 集群
     • Kubernetes worker 节点和节点池

   • 定制创建：对于客户已经拥有服务、网络、基础设施的企业环境，必须定制 OKE 部署，确保合规性、与客户机体系结构、资源保持一致并遵循优秀实践。

     在本教程中，我们将选择定制创建以保留上面所示的体系结构。

   

4. 输入集群 Name（名称）、 Compartment（区间）、Kubernetes version（Kubernetes 版本）并单击 Next（下一步）。

   

5. 在网络设置页中，输入以下信息，然后单击下一步。

   • 网络类型：选择 VCN 本机 Pod 网络。有关更多信息，请参见 POD Networking 。
   • VCN：选择 VCN。
   • 子网：选择专用子网和公共子网。在本教程中，我们将公共子网用于负载平衡器，将专用子网用于 api 端点。

   

6. 在节点池页中，输入以下信息。

   • 名称：输入节点池的名称。
   • 区间：选择您的区间。
   • 节点类型：选择托管节点类型。有关更多信息，请参见 Comparing Virtual Nodes with Managed Nodes 。
   • 版本：选择 Kubernetes 的版本。
   • 节点放置配置：
     • 可用性域：配置可用性域。
     • Worker 节点子网：设置将在此节点池中创建的节点的专用子网。
     • 容错域：选择要将节点分发到的容错域。
   • 配置和映像：为 worker 节点选择配置和映像。
     • 节点配置：选择 VM.Standard.E3.Flex Shape (16GB RAM memory and 1 OCPU)。
     • 图像：选择 Oracle-Linux-8.9-2024.01.26-0-OKE-1.28.2-679 图像。
   • 节点计数：为此教程输入 1，1 就足够了。
   • 引导卷：我们不会修改引导卷参数。
   • Pod 通信：选择专用子网。

   

   

7. 查看 Kubernetes 集群配置，然后单击创建集群。

   注：在单击创建集群之前，请确保在每个 OKE 网络子网中为负载平衡器、API 端点和 worker 节点配置了所有入站和出站安全列表规则。有关更多信息，请参见 Network Resource Configuration for Cluster Creation and Deployment 。

   

   要验证 Kubernetes 集群，请导航到 Developer Services（开发人员服务）、 Containers & Artifacts（容器和对象）和 Kubernetes Clusters (OKE) 。

   

8. 要访问 Kubernetes 集群，请单击 Kubernetes 集群名称和访问集群。

   您可以看到云 Shell 访问已禁用，本地访问已启用，因为当我们选择 API 端点子网时，我们选择了一个专用子网，即更安全，访问 Kubernetes 集群的唯一方法是使用本地计算机，因此，这正是本教程中用于管理主机 Oracle Linux VM 的配置。选择本地访问。

   

   注：必须已安装 OCI CLI、Docker 和 kubectl。有关更多信息，请参见 Installing kubectl 。

9. 管理主机准备就绪后，执行以下命令可从本地计算机访问 Kubernetes 集群。

   1. 验证 OCI CLI 版本。

      oci -v
      

   2. 在家中创建 kubeconfig 目录。

      mkdir -p $HOME/.kube
      

   3. 使用 VCN 本机专用端点创建 kubeconfig 文件。

      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. 设置 kubeconfig 环境变量。

      export KUBECONFIG=$HOME/.kube/config
      

10. 要验证 Kubernetes 集群的访问权限，请运行 kubectl 命令。

    • 获取 OKE worker 节点。

      kubectl get nodes
      

      

    • 获取 OKE 云池。

      kubectl get pods -A
      

      

任务 6：在 Node.js 中开发和部署 API REST 应用，在 OCI 通知中发布消息

在本教程中，我们将在 Node.js 中开发和部署 API REST 应用，以从 HTTP Post 请求正文获取 JSON，并在 OCI 通知中将此 JSON 正文作为消息发布。

我们将创建一个 Node.js 项目，构建项目，将其推送到 Oracle Cloud Infrastructure 容器注册表并在 OKE 中部署。我们将使用为 OCI Functions 配置的现有 Oracle Linux 管理主机，因此我们已经安装了 Node.js 和 Docker。

1. 运行以下命令在本地计算机主目录中创建具有项目名称的文件夹，并将目录更改为项目文件夹。

   mkdir api_rest_application_oke
   

   cd api_rest_application_oke
   

2. 要初始化项目，请运行以下命令并配置 package.json 文件，如下图中所示。

   npm init
   

   

3. 在开发 Node.js 代码之前，我们需要安装项目所需的库。

   • API REST 应用程序需要像 Web 应用程序一样工作，因此我们需要 express 库。

     npm install express
     

     

   • 我们需要从 HTTP POST 请求中获取 JSON 正文，因此我们需要 body-parser 库。

     npm install body-parser
     

     

   • 应用程序需要通过 OCI 进行验证才能访问其服务，因此我们需要 oci-common 库。

     npm install oci-common
     

     

   • 要在 OCI 通知中发布来自请求正文的消息，我们需要关联库。

     npm install oci-ons
     

     

   我们的 package.json 具有以下依赖项。

   

4. 配置 Node.js 项目时，可以在 index.js 文件中创建代码。下面是源代码。

   我们将在 OCI 中使用配置文件从代码进行验证，类似于我们配置 OCI CLI 的方式。在这两种情况下，密钥和配置文件都放置在 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. 在同一文件夹中，创建 Dockerfile，这将允许我们创建容器映像。

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

6. 在本地 Docker 资料档案库中构建和推送项目的映像。

   docker build . -t apirestapp:latest
   

   

   验证本地 Docker 系统信息库中的映像。

   docker images
   

   

   注:

   • 您必须具有 Oracle Cloud Infrastructure 容器注册表。请参阅任务 3.6。

     

   • 您必须登录到 Oracle Cloud Infrastructure 容器注册表，因为我们使用的是应登录的同一台本地计算机管理主机。请参阅任务 3.7。

7. 我们可以在 Oracle Cloud Infrastructure 容器注册表中标记 API REST 应用映像。

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

   在本地 Docker 系统信息库中进行验证。

   docker images
   

   

   将映像推送到 Oracle Cloud Infrastructure 容器注册表。

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

   

   要查看 Oracle Cloud Infrastructure 容器注册表中的 OKE 映像应用程序，请转至开发人员服务、容器和对象和容器注册表。

   

8. 映像位于 Oracle Cloud Infrastructure 容器注册表中后，我们可以转到本地 Oracle Linux VM 管理主机并在 OKE 中部署此映像。对于本教程，运行以下命令为 OKE 创建名称空间和密钥。

   1. 访问项目文件夹。

      cd api_rest_application_oke/
      

   2. 为 OKE 创建名称空间。

      kubectl create namespace ns-tutorial
      

      

   3. 验证名称空间。

      kubectl get namespace ns-tutorial
      

      

   4. 为 OKE 创建密钥。

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

      

   5. 验证密钥。

      kubectl get secrets -A
      

      

9. 我们已准备好 OKE 环境，因此请将应用程序映像从 Oracle Cloud Infrastructure 容器注册表部署到 OKE。

   注：要部署应用程序映像，必须具有清单文件。在本教程中，以下 yaml 文件是清单文件，用于部署应用程序并创建使用 80 端口监听的 OCI 负载平衡器中表示的入站服务。

   • 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
     

   • 在您保存清单文件的文件夹中执行 kubectl 命令。

     kubectl apply -f apirest_application_manifest.yaml
     

     现在，已部署应用程序并在 OKE 中创建入站负载平衡器服务，

     

   • 要验证在 OKE 中创建的 pod 和服务，请运行以下命令。

     kubectl get pods -A
     

     

     kubectl get svc -A
     

     

   注：请从以下位置下载 API REST 应用程序项目：api_rest_application_oke.zip 。

任务 7：将具有 JSON 正文的 HTTP POST 请求到在 API REST 应用程序的负载平衡器中公开的 URL

在此任务中，我们将使用 Postman 客户端中的 JSON 消息正文发出 HTTP POST 请求，其中包含用于在存储桶中创建文件的基本数据。此请求将发送到 OKE 中的 API REST 应用程序，在 OCI 通知主题中推送消息将触发具有逻辑的函数，以在特定存储桶中创建文本文件，如“简介”中的体系结构中所示。

1. 要安装 Postman，请参见 Postman Installation 。

2. 打开 Postman 应用程序。

   1. 单击汉堡菜单中的文件，然后选择新建。

      

   2. 选择 HTTP 。

      

   3. 输入在 OKE 中部署的 API REST 应用程序公开的 URL：http://"IP ADDRESS LOAD BALANCER"/api/receive-json，然后选择 POST 方法。在 Body（正文）标记中，选择 raw（原始），然后在空白字段中输入 JSON 消息。

      

3. 单击发送可发送请求。

   

   要验证在 OCI 对象存储的特定存储桶中创建的文件，请转至存储、对象存储和归档存储、存储桶，然后单击您的存储桶。

   

   

在本教程中，您将 OCI 通知与新用例结合使用，集成了 API、OCI SDK、OKE 中部署的 Kubernetes 应用、OCI Functions 和 OCI Object Storage 等多个服务。

相关链接

• 安装 Oracle Cloud Infrastructure 命令行界面 (OCI CLI)

• 创建 VCN

• 创建子网

• VCN 路由表

• Internet 网关

• 创建区间

• 安装 Fn 项目 CLI

• 如何在 Oracle Linux 8/7 上安装 Docker

• Getting an Auth Token

• oci-objectstorage 磁带库

• oci-common 库

• 创建集群

• POD 网络

• 用于创建和部署集群的网络资源配置

• 在 Linux 上安装和设置 kubectl

• 安装和更新 Postman

确认

• 作者 - Iván Alexander Vásquez Chinome（Oracle LAD A 团队云解决方案专家）

更多学习资源

浏览 docs.oracle.com/learn 上的其他实验室，或者通过 Oracle Learning YouTube 频道访问更多免费学习内容。此外，请访问 education.oracle.com/learning-explorer 以成为 Oracle Learning Explorer。

有关产品文档，请访问 Oracle 帮助中心。

---

标题和版权信息

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

F96554-01

April 2024

Copyright ©2024,

Oracle 和/或其关联公司。