Hinweis:

Nachricht in OCI-Benachrichtigungen veröffentlichen, Funktion auslösen und Datei in OCI-Objektspeicher-Bucket erstellen

Einführung

Sie können einen Publish-Abonnementservice wie Oracle Cloud Infrastructure-(OCI-)Benachrichtigungen konfigurieren, der Nachrichten an Endpunkte überträgt, die Alerts ausgeben und über konfiguriertes Abonnement Maßnahmen ergreifen können. Dabei wird nicht nur die Verwendung von Oracle Cloud Infrastructure Monitoring oder OCI Connector Hub unterstützt Fälle, aber auch die Ereignisse können aus den Kundenanwendungen generiert werden. API-Nachrichten, die eine sofortige Aktion darstellen müssen, die ausgeführt wird, wenn die Anwendung eine Nachricht sendet, wenn ein Ereignis OCI Notifications auslöst.

Die Architektur kann mehr oder weniger komplex sein, aber für diesen Anwendungsfall stellt der Client eine HTTP POST-Anforderung aus und sendet im Body eine JSON mit bestimmten Attributen zu eine Datei erstellen, wie Dateiname, Name des Buckets, in dem Sie die Datei in OCI Object Storage erstellen möchten, und die Nachricht, die sich in der Datei befindet.

Dann ruft die in Oracle Cloud Infrastructure Container Engine for Kubernetes (OKE) bereitgestellte und in Node.js entwickelte API-REST-Anwendung das JSON aus dem Anforderungsbody ab. Außerdem werden in dieser Anwendung die OCI-Librarys verwendet, um eine Nachricht in OCI Notifications veröffentlichen, für die bereits eine Node.js-Funktion abonniert und zum Erstellen der Textdatei in einem bestimmten Bucket in OCI Object Storage mit den gesendeten JSON-Parametern entwickelt wurde

OCI-Architektur

OCI-Architektur

Anwendungsfallarchitektur

Anwendungsfallarchitektur

In diesem Tutorial wird mit der Konfiguration vom letzten Service begonnen, bis der erste Service in Oracle Cloud Infrastructure (OCI) erreicht ist:

Ziele

Voraussetzungen

Aufgabe 1: Bucket in OCI Object Storage erstellen

  1. Melden Sie sich bei der OCI-Konsole an, navigieren Sie zu Speicher, Object Storage und Archive Storage, Buckets, und wählen Sie das Compartment Ihrer Präferenz aus.

  2. Klicken Sie auf Bucket erstellen, und geben Sie die folgenden Informationen ein.

    • Zeitraumname: Geben Sie den Namen des Zeitraums ein. Beispiel: data oder ein anderer Name.
    • Standardspeicher-Tier: Wählen Sie für dieses Tutorial die Option Standard aus.
    • Verschlüsselung: Wählen Sie Mit von Oracle verwalteten Schlüsseln verschlüsseln.
    • Ressourcenlogging: Wählen Sie Ressourcenlogging aktiviert aus, um die Vorgänge im Bucket zu überwachen.

    Bucket erstellen

Aufgabe 2: OCI-Funktionen konfigurieren und erstellen

  1. Gehen Sie zur OCI-Konsole, navigieren Sie zu Entwicklerservices, Funktionen, Anwendungen, und wählen Sie Compartment aus.

  2. Klicken Sie auf Anwendung erstellen, und geben Sie die folgenden Informationen ein.

    • Name: Geben Sie den Namen für die Funktionsanwendung ein.
    • VCN: Wählen Sie ein unter den Voraussetzungen erstelltes VCN aus.
    • Subnetze: Wählen Sie ein Subnetz aus, das unter Voraussetzungen erstellt wurde. In diesem Tutorial haben wir ein öffentliches Subnetz konfiguriert.
    • Ausprägung: Wählen Sie die Ausprägung für den Prozessor aus, der von dieser Anwendung unterstützt wird. Für dieses Tutorial ist es GENERIC_X86.

    Funktionsanwendung erstellen

  3. Aktivieren Sie die Logs, um die Ausführung zu verfolgen und Fehler der OCI Functions-Anwendung anzuzeigen. Klicken Sie also im Detail der Funktionsanwendung unter Ressourcen auf Logs, und wählen Sie Log aktivieren aus, um das Compartment, die Loggruppe, den Lognamen und die Uhrzeit der Logaufbewahrung zu konfigurieren.

    Logs aktivieren Funktionsanwendung

Aufgabe 3: OCI-Funktionen mit FDK Node.js konfigurieren, entwickeln und per Push übertragen, um eine neue Textdatei zu erstellen

Konfigurieren, entwickeln und übertragen Sie OCI Functions mit FDK Node.js, um eine neue Textdatei aus JSON-Parametern in einem bestimmten Bucket zu erstellen.

Hinweis: Konfigurieren Sie Ihren Client wie Desktop, PC, Laptop oder virtuelle Maschine (VM) und den Kontext Ihrer Funktion, in dem Sie mit Fn Project arbeiten, da OCI Functions von der Open-Source-Engine Fn Project unterstützt wird, um Erstellungs-, Lese-, Aktualisierungs- und Löschvorgänge in OCI Functions auszuführen.

Wir verwenden eine Oracle Linux 8 VM (Admin-Host) in OCI, wie in der Architektur in der Einführung gezeigt.

  1. Gehen Sie zur OCI-Konsole, navigieren Sie zu Entwicklerservices, Funktionen, Anwendungen, und klicken Sie auf Ihre Funktionsanwendung.

  2. Klicken Sie im Abschnitt Ressourcen auf Erste Schritte, und wählen Sie Lokales Setup aus, um eine externe Oracle Linux-VM zu verwenden.

    Lokales Setup

    Hinweis: Sie müssen die folgenden Komponenten installiert haben.

    • OCI-Befehlszeilenschnittstelle (CLI).

    • Node.js in Oracle Linux.

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

      Die Version von Node.js muss von OCI FDK Functions unterstützt werden.

      In OCI Functions unterstützte Version - node.js

      Wenn die Version nicht unterstützt wird, müssen Sie die folgenden Befehle ausführen.

      Beispiel:

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

    • Fn-Projekt-CLI in Ihrer VM installiert. Weitere Informationen finden Sie unter Fn-Projekt-CLI installieren.

  3. Erstellen Sie Ihr Projekt in der gewünschten Programmiersprache. In diesem Tutorial verwenden wir Node.js. Um ein neues Projekt zu erstellen, führen Sie den folgenden Befehl aus.

    fn init --runtime node "Name_Of_Your_Project"

    Beispiel:

    fn init --runtime node app_mess_createFile_os_function

  4. Um auf den Projektordner zuzugreifen, führen Sie den folgenden Befehl aus.

    cd "Name_Of_Your_Project"/

    Beispiel:

    cd app_mess_createFile_os_function/

  5. Erstellen und aktualisieren Sie einen bestimmten Kontext für unser Compartment und die Oracle Functions-API-URL für Ihre Region, die unter Erste Schritte angegeben ist.

    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"

    Beispiel:

    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. Geben Sie den Pfad der Oracle Cloud Infrastructure Container Registry ein, in die das Anwendungsimage übertragen wird.

    Hinweis: Wenn Sie nicht über die Oracle Cloud Infrastructure Container Registry verfügen, müssen Sie dieses Repository erstellen, um das Funktionsimage per Push zu übertragen.

    1. Gehen Sie zu Entwicklerservices, Container und Artefakte, Container Registry, und klicken Sie auf Repository erstellen.

    2. Geben Sie die folgenden Informationen ein, und klicken Sie auf Erstellen.

      • Erstellen in Compartment: Wählen Sie das Compartment aus,
      • Zugriff: Wählen Sie Öffentlich aus.
      • Repository-Name: Geben Sie den Repository-Namen ein.

      Oracle Cloud Infrastructure-Container Registry erstellen

    Nachdem Sie Oracle Cloud Infrastructure Container Registry erstellt haben, legen Sie den Pfad dieses Repositorys so lange fest, bis das Präfix im Kontext steht.

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

    Beispiel:

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

  7. Melden Sie sich bei Oracle Cloud Infrastructure Container Registry an.

    Hinweis: Um sich anzumelden, Images zu erstellen, abzurufen und in das Repository zu übertragen, benötigen Sie:

    Führen Sie den folgenden Befehl aus, um sich bei der Oracle Cloud Infrastructure Container Registry anzumelden.

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

    Password: xxxxxx

    Beispiel (In diesem Beispiel wird der Benutzername mit Oracle Identity Cloud Service föderiert, sodass er enthalten sein muss):

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

    Password: xxxxxx

    Anmelden

  8. Nachdem Sie die OCI Functions konfiguriert haben, entwickeln wir das Programm Node.js, um eine Textdatei in einem bestimmten Bucket zu erstellen.

    Wir haben das Funktionsprojekt in Aufgabe 3.3 erstellt, es erstellt die folgenden Dateien im Projektordner:

    • func.js (In dieser Datei schreiben wir die Projektlogik node.js).
    • func.yaml (Dies ist die Funktionskonfigurationsdatei).
    • package.json (Diese Datei gibt die Node.js-Abhängigkeiten an, die für die Projektlogik erforderlich sind).

    In diesem Projekt müssen Sie die folgenden Node.js OCI-SDK-Abhängigkeiten hinzufügen: OCI-objectstorage und OCI-common. Führen Sie folgenden Befehl aus, um Abhängigkeiten zu installieren.

    npm install oci-common

    Abhängigkeits-oci-common wird hinzugefügt

    npm install oci-objectstorage

    Abhängigkeits-oci-objectstorage hinzufügen

    Die in der Datei package.json hinzugefügten Abhängigkeiten werden angezeigt.

    Abhängigkeiten hinzugefügt

    Wir werden uns in OCI über den Code mit der Konfigurationsdatei authentifizieren, ähnlich wie bei der Konfiguration der OCI-CLI, bei der sowohl die Schlüssel als auch die Konfigurationsdatei im Fn-Projektordner abgelegt wurden.

    Funktion - Projektordner

    Im Folgenden finden Sie den Quellcode Node.js. Die Details jedes Codefragments werden mit Kommentaren erläutert.

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

    Hinweis: Laden Sie das OCI Functions-Projekt von hier herunter: app_mess_createFile_os_function.zip.

  9. Projekt wird erstellt. Stellen Sie sicher, dass Sie bei Oracle Cloud Infrastructure Container Registry angemeldet bleiben. Wir erstellen und übertragen das Image in Oracle Cloud Infrastructure Container Registry und stellen diese Funktion in der OCI Functions-Anwendung bereit.

    1. Gehen Sie zur OCI-Konsole, navigieren Sie zu Entwicklerservices, Funktionen, Anwendungen, und klicken Sie auf Ihre Funktionsanwendung.

      Auf unserem lokalen Rechner müssen wir uns im Projektordner von OCI Functions befinden.

      fn deploy --app name_of_your_function_application

      Beispiel:

      fn deploy --app fn-demo-apgw

      Funktion in Oracle Cloud Infrastructure Container Registry bereitstellen

    2. Um zu validieren, dass das Image in Oracle Cloud Infrastructure Container Registry bereitgestellt wurde, navigieren Sie zur OCI-Konsole, und navigieren Sie zu Entwicklerservices, Container und Artefakte und Container Registry.

      In Oracle Cloud Infrastructure Container Registry übertragenes OCI-Konsolenimage einchecken

      Um zu prüfen, ob die Funktion in der OCI Functions-Anwendung bereitgestellt ist, navigieren Sie zur OCI-Konsole, und navigieren Sie zu Entwicklerservices, Funktionen, Anwendungen. Klicken Sie auf Ihre Funktionsanwendung, und prüfen Sie, ob das Image dort mit dem Oracle Cloud Infrastructure Container Registry-Pfad referenziert wird.

      In OCI Functions bereitgestelltes OCI-Konsolenimage einchecken

  10. Führen Sie einen Test auf Ihrem lokalen Rechner aus. Führen Sie den folgenden Fn-Projektbefehl aus, um eine Eingabe mit den Parametern zu simulieren, die im JSON-Format bereitgestellt werden.

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

    Beispiel:

    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

    Aufruf der Funktion

    Um die im Bucket erstellte Datei zu prüfen, navigieren Sie zu Speicher, Object Storage und Archive Storage, Buckets, klicken Sie auf den Bucket, und validieren Sie, ob die Datei vorhanden ist.

    Bucket wird validiert

    Datei wird überprüft

Aufgabe 4: Neues OCI Notifications-Thema und ein Abonnement erstellen, das OCI-Funktionen als Endpunkt verknüpft

  1. Erstellen und verwenden Sie OCI Notifications. Wenn eine Nachricht in einem Thema in diesem Service veröffentlicht wird, wird ein Trigger für einen Endpunkt generiert. Dieser Endpunkt ist die Funktion, die in Aufgabe 3 erstellt wird.

    Navigieren Sie zur OCI-Konsole, und navigieren Sie zu Entwicklerservices, Anwendungsintegration und Benachrichtigungen. Klicken Sie auf Thema erstellen, und geben Sie den Namen für dieses Thema ein.

    Thema in OCI-Benachrichtigungen erstellen

    Thema in OCI-Benachrichtigungen erstellt

  2. Um ein Abonnement für dieses Thema zu erstellen, klicken Sie auf Ihr Thema und dann auf Abonnement erstellen. In diesem Tutorial wählen wir Functions als Endpunkt aus. Sie können einen Endpunkt wie E-Mail, Slack, SMS, PagerDuty oder HTTPS-URL auswählen und die Funktions-Compartment, die Oracle Functions-Anwendung und die Funktion auswählen.

    Subscription wird erstellt

    Abonnement erstellt

    Hinweis: In OCI Notifications können wir bei Bedarf mehrere Abonnements mit einem anderen Endpunkt erstellen.

  3. Von OCI Notifications aus können wir eine Nachricht im JSON-Format mit den erforderlichen Variablen veröffentlichen, ähnlich wie in Aufgabe 3 für OCI Functions.

    Navigieren Sie zur OCI-Konsole, und navigieren Sie zu Entwicklerservices, Anwendungsintegration und Benachrichtigungen. Klicken Sie auf das Thema, und geben Sie die Nachricht ein, wie in der folgenden Abbildung dargestellt.

    OCI-Benachrichtigung ausführen

    Um den Bucket zu prüfen, navigieren Sie zu Speicher, Object Storage und Archive Storage und Buckets. Klicken Sie auf Ihren Bucket, und validieren Sie, ob die Datei vorhanden ist.

    Test von OCI-Benachrichtigung

    Aus OCI-Benachrichtigung erstellte Testdatei prüfen

Aufgabe 5: Kubernetes-Cluster in Oracle Cloud Infrastructure Container Engine for Kubernetes erstellen und konfigurieren

In dieser Aufgabe erstellen wir ein einfaches Kubernetes-Cluster. Weitere Informationen finden Sie unter OKE-Cluster erstellen.

  1. Gehen Sie zur OCI-Konsole, navigieren Sie zu Entwicklerservices, Container und Artefakte, und klicken Sie auf Kubernetes-Cluster (OKE).

  2. Klicken Sie auf der Seite Cluster auf Cluster erstellen.

  3. Wir haben zwei Workflows, um das Cluster zu erstellen. Klicken Sie auf Benutzerdefiniert erstellen und Weiterleiten.

    • Schnellerstellung: Dies ist einfacher, schneller und stellt automatisch alle Elemente bereit, die OKE für seinen Vorgang benötigt, wie:

      • Virtual Cloud Network (VCN)
      • Internetgateway (IG)
      • NAT-Gateway (NAT)
      • Servicegateway (SGW)
      • Kubernetes-Cluster
      • Kubernetes-Worker-Knoten und Knotenpool

    • Benutzerdefinierte Erstellung: Für Unternehmensumgebungen, in denen bereits Kunden über Services, Netzwerk und Infrastruktur verfügen, ist es wichtig, das OKE-Deployment entsprechend der Clientarchitektur, den Ressourcen und den Best Practices anzupassen.

      In diesem Tutorial wählen wir Benutzerdefinierte Erstellung, um die oben gezeigte Architektur beizubehalten.

    Optionen zum Erstellen des OKE-Clusters

  4. Geben Sie den Cluster-Namen, das Compartment und die Kubernetes-Version ein, und klicken Sie auf Weiter.

    Cluster erstellen

  5. Geben Sie auf der Seite Netzwerksetup die folgenden Informationen ein, und klicken Sie auf Weiter.

    • Netzwerktyp: Wählen Sie VCN-natives Podnetworking aus. Weitere Informationen finden Sie unter POD-Networking.
    • VCN: Wählen Sie Ihr VCN aus.
    • Subnetze: Wählen Sie ein privates und ein öffentliches Subnetz aus. In diesem Tutorial verwenden wir das öffentliche Subnetz für den Load Balancer und das private Subnetz für den API-Endpunkt.

    Netzwerksetup

  6. Geben Sie auf der Seite Knotenpools die folgenden Informationen ein.

    • Name: Geben Sie den Namen des Knotenpools ein.
    • Compartment: Wählen Sie Ihr Compartment aus.
    • Knotentyp: Wählen Sie den Knotentyp Verwaltet aus. Weitere Informationen finden Sie unter Virtuelle Knoten mit verwalteten Knoten vergleichen.
    • Version: Wählen Sie die Version von Kubernetes aus.
    • Node Placement-Konfiguration:
      • Availability-Domain: Konfigurieren Sie die Availability-Domain.
      • Worker-Knotensubnetz: Legen Sie das private Subnetz für die Knoten fest, die in diesem Knotenpool erstellt werden.
      • Faultdomain: Wählen Sie die Faultdomains aus, in denen die Knoten verteilt werden sollen.
    • Ausprägung und Image: Wählen Sie eine Ausprägung und ein Image für unsere Worker-Knoten aus,
      • Knotenausprägung: Wählen Sie VM.Standard.E3.Flex Shape (16GB RAM memory and 1 OCPU) aus.
      • Image: Wählen Sie das Image Oracle-Linux-8.9-2024.01.26-0-OKE-1.28.2-679 aus.
    • Knotenanzahl: Geben Sie 1 ein. Für dieses Tutorial ist 1 ausreichend.
    • Boot-Volume: Die Boot-Volume-Parameter werden nicht geändert.
    • Podkommunikation: Wählen Sie ein privates Subnetz aus.

    Knotenpools 1

    Knotenpools 2

  7. Prüfen Sie die Kubernetes-Clusterkonfiguration, und klicken Sie auf Cluster erstellen.

    Hinweis: Bevor Sie auf Cluster erstellen klicken, stellen Sie sicher, dass alle Ingress- und Egress-Sicherheitslistenregeln in jedem OKE-Netzwerksubnetz für Load Balancer, API-Endpunkt und Worker-Knoten konfiguriert wurden. Weitere Informationen finden Sie unter Netzwerkressourcenkonfiguration für Clustererstellung und -Deployment.

    OKE prüfen

    Um das Kubernetes-Cluster zu prüfen, navigieren Sie zu Entwicklerservices, Container und Artefakte und Kubernetes-Cluster (OKE).

    OKE-Cluster erstellt

  8. Um auf das Kubernetes-Cluster zuzugreifen, klicken Sie auf den Kubernetes-Clusternamen und Auf Cluster zugreifen.

    Sie können sehen, dass der Cloud Shell-Zugriff deaktiviert und der lokale Zugriff aktiviert ist, da wir bei der Auswahl des API-Endpunktsubnetzes ein privates Subnetz ausgewählt haben. Die einzige Möglichkeit, auf das Kubernetes-Cluster zuzugreifen, ist die Verwendung eines lokalen Rechners. Daher verwenden wir in diesem Tutorial genau die Konfiguration mit unserem Admin-Host Oracle Linux VM. Wählen Sie Lokaler Zugriff aus.

    Auf Cluster zugreifen

    Hinweis: Die OCI-CLI, Docker und kubectl müssen installiert sein. Weitere Informationen finden Sie unter kubectl installieren.

  9. Nachdem der Admin-Host bereit ist, führen Sie den folgenden Befehl aus, um Zugriff von Ihrem lokalen Rechner auf das Kubernetes-Cluster zu erhalten.

    1. Prüfen Sie die OCI-CLI-Version.

      oci -v

    2. Erstellen Sie das kubeconfig-Verzeichnis in Ihrem Home-Verzeichnis.

      mkdir -p $HOME/.kube

    3. Erstellen Sie eine kubeconfig-Datei mit einem VCN-nativen privaten Endpunkt.

      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. Legen Sie die kubeconfig-Umgebungsvariable fest.

      export KUBECONFIG=$HOME/.kube/config

  10. Um den Zugriff auf das Kubernetes-Cluster zu prüfen, führen Sie kubectl-Befehle aus.

    • Rufen Sie die OKE-Worker-Knoten ab.

      kubectl get nodes

      kubectl: Knoten abrufen

    • Holen Sie sich die OKE-Pods.

      kubectl get pods -A

      kubectl Get-Pods

Aufgabe 6: API-REST-Anwendung in Node.js entwickeln und bereitstellen und Nachricht in OCI-Benachrichtigungen veröffentlichen

In diesem Tutorial entwickeln und implementieren wir eine API-REST-Anwendung in Node.js, um die JSON aus dem HTTP-Postanforderungsbody abzurufen und diesen JSON-Body als Nachricht in OCI Notifications zu veröffentlichen.

Wir erstellen ein Node.js-Projekt, erstellen das Projekt, übertragen es in die Oracle Cloud Infrastructure Container Registry und stellen es in OKE bereit. Wir verwenden einen vorhandenen Oracle Linux-Administrationshost, der für OCI Functions konfiguriert ist. Daher haben wir Node.js und Docker bereits installiert.

  1. Führen Sie die folgenden Befehle aus, um einen Ordner mit dem Namen des Projekts im lokalen Rechner-Home zu erstellen und in den Projektordner zu wechseln.

    mkdir api_rest_application_oke

    cd api_rest_application_oke

  2. Um ein Projekt zu initialisieren, führen Sie den folgenden Befehl aus, und konfigurieren Sie die Datei package.json wie in der folgenden Abbildung dargestellt.

    npm init

    nodejs-Projekt

  3. Bevor Sie den Node.js-Code entwickeln, müssen Sie die erforderlichen Librarys für das Projekt installieren.

    • Die API-REST-Anwendung muss wie eine Webanwendung funktionieren. Daher ist eine express-Bibliothek erforderlich.

      npm install express

      Express-Bibliothek wird installiert

    • Der JSON-Body muss aus der HTTP-POST-Anforderung abgerufen werden. Daher ist die body-parser-Bibliothek erforderlich.

      npm install body-parser

      Body-Parser-Bibliothek installieren

    • Die Anwendung muss sich bei OCI authentifizieren, um Zugriff auf ihre Services zu haben. Daher benötigen wir die oci-common-Library.

      npm install oci-common

      oci-common Library wird installiert

    • Um eine Nachricht in OCI Notifications zu veröffentlichen, die aus dem Anforderungstext stammt, ist die oci-ons-Library erforderlich.

      npm install oci-ons

      OCI-ons-Bibliothek wird installiert

    Unsere package.json hat die folgenden Abhängigkeiten.

    Datei package.json

  4. Wenn das Projekt Node.js konfiguriert ist, können wir unseren Code in der Datei index.js erstellen. Im Folgenden ist der Quellcode aufgeführt.

    Wir authentifizieren uns in OCI über den Code mit der Konfigurationsdatei, ähnlich wie wir die OCI-CLI konfiguriert haben. In beiden Fällen werden die Schlüssel und die Konfigurationsdatei im Projektordner der API-REST-Anwendung abgelegt, wie in der folgenden Abbildung dargestellt.

    Konfigurationsdatei in API Rest Project

    • 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. Erstellen Sie im selben Ordner Dockerfile. Dadurch können Sie ein Containerimage erstellen.

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

  6. Erstellen und übertragen Sie das Image des Projekts im lokalen Docker-Repository.

    docker build . -t apirestapp:latest

    Docking-Bild erstellen

    Prüfen Sie das Image im lokalen Docker-Repository.

    docker images

    Docking-Bilder überprüfen

    Hinweis:

    • Sie benötigen Oracle Cloud Infrastructure Container Registry. Siehe Aufgabe 3.6.

      Erstellung des OKE-Anwendungs-Repositorys

    • Sie müssen bei Oracle Cloud Infrastructure Container Registry angemeldet sein, da wir denselben lokalen Rechner-Admin-Host verwenden, der angemeldet sein muss. Siehe Aufgabe 3.7.

  7. Wir können das API-REST-Anwendungsimage in Oracle Cloud Infrastructure Container Registry taggen.

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

    Prüfen Sie dies im lokalen Docker-Repository.

    docker images

    OKE-Anwendung taggen

    Übertragen Sie das Image an Oracle Cloud Infrastructure Container Registry.

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

    OKE-Anwendung pushen

    Um die OKE-Imageanwendung in Oracle Cloud Infrastructure Container Registry zu prüfen, navigieren Sie zu Entwicklerservices, Container und Artefakte und Container Registry.

    Bild in OKE Containe Registry

  8. Sobald sich das Image in der Oracle Cloud Infrastructure Container Registry befindet, können wir zu unserem lokalen Oracle Linux-VM-Administrationshost gehen und dieses Image in OKE bereitstellen. Führen Sie für dieses Tutorial den folgenden Befehl aus, um den Namespace und das Secret für OKE zu erstellen.

    1. Greifen Sie auf den Projektordner zu.

      cd api_rest_application_oke/

    2. Erstellen Sie einen Namespace für OKE.

      kubectl create namespace ns-tutorial

      Namespace-Oke erstellen

    3. Prüfen Sie den Namespace.

      kubectl get namespace ns-tutorial

      Namespace-Oke prüfen

    4. Erstellen Sie ein Secret für OKE.

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

      Secrete Oke erstellen

    5. Prüfen Sie das Secret.

      kubectl get secrets -A

      Secret Oke prüfen

  9. Die OKE-Umgebung ist bereits bereit. Stellen Sie das Anwendungsimage aus Oracle Cloud Infrastructure Container Registry in OKE bereit.

    Hinweis: Um das Anwendungsimage bereitzustellen, ist eine Manifestdatei erforderlich. In diesem Tutorial ist die folgende yaml-Datei die Manifestdatei. Sie wird verwendet, um die Anwendung bereitzustellen und den Ingress-Service zu erstellen, der in einem OCI Load Balancer dargestellt wird, der mit dem 80-Port horcht.

    • 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

    • Führen Sie den kubectl-Befehl in dem Ordner aus, in dem Sie die Manifestdatei gespeichert haben.

      kubectl apply -f apirest_application_manifest.yaml

      Jetzt wird die Anwendung bereitgestellt, und der Ingress-Load-Balancer-Service wird in OKE erstellt.

      Manifest in OKE anwenden

    • Um den in OKE erstellten Pod und Service zu validieren, führen Sie den folgenden Befehl aus.

      kubectl get pods -A

      OKE PODS

      kubectl get svc -A

      OKE-Services

    Hinweis: Laden Sie das API-REST-Anwendungsprojekt von hier herunter: api_rest_application_oke.zip.

Aufgabe 7: HTTP-POST mit JSON-Body an URL anfordern, die im Load Balancer der API-REST-Anwendung angegeben ist

In dieser Aufgabe erstellen wir eine HTTP-POST-Anforderung mit JSON-Nachrichtentext vom Postman-Client, der die Basisdaten zum Erstellen einer Datei in einem Bucket enthält. Diese Anforderung wird an die API-REST-Anwendung in OKE gesendet. Wenn Sie die Nachricht im OCI-Benachrichtigungsthema pushen, wird eine Funktion mit der Logik ausgelöst, eine Textdatei in einem bestimmten Bucket zu erstellen, wie in der Architektur in der Einführung dargestellt.

  1. Zur Installation von Postman wird auf Postman Installation verwiesen.

  2. Öffnen Sie die Postman-Anwendung.

    1. Klicken Sie auf das Hamburger-Menü Datei, und wählen Sie Neu aus.

      Postman-Menü

    2. Wählen Sie HTTP aus.

      HTTP-Option

    3. Geben Sie die von der API-REST-Anwendung bereitgestellte URL ein, die in OKE bereitgestellt wird: http://"IP ADDRESS LOAD BALANCER"/API/receive-json, und wählen Sie die Methode POST aus. Wählen Sie im Tag Haupttext die Option raw aus, und geben Sie die JSON-Nachricht in das leere Feld ein.

      Postman-Anforderung

  3. Klicken Sie auf Senden, um die Anfrage zu senden.

    Antwortanforderung - Postman

    Um die im spezifischen Bucket in OCI Object Storage erstellte Datei zu prüfen, gehen Sie zu Speicher, Object Storage und Archive Storage, Buckets, und klicken Sie auf Ihren Bucket.

    Letzte Datei, die in einem bestimmten Bucket in diesem Tutorial erstellt wurde

    Letzte Textdatei

In diesem Tutorial haben Sie OCI Notifications mit einem neuen Anwendungsfall verwendet und mehrere Services wie APIs, OCI SDK, Kubernetes-Anwendungen integriert, die in OKE, OCI Functions und OCI Object Storage bereitgestellt werden.

Danksagungen

Weitere Lernressourcen

Lernen Sie andere Übungen auf docs.oracle.com/learn kennen, oder greifen Sie auf weitere kostenlose Lerninhalte im Oracle Learning YouTube Channel zu. Außerdem können Sie education.oracle.com/learning-explorer besuchen, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.