Automatisierung erstellen

Erstellen und stellen Sie die Anwendungs- und Automatisierungsfunktion bereit.

Oracle Functions-Anwendung erstellen

Eine Anwendung ist eine logische Gruppierung von Funktionen, mit denen Sie Ressourcen für die gesamte Gruppe zuweisen und konfigurieren und die Funktionen während der Laufzeit isolieren können.

Bevor Sie die Anwendung erstellen können, müssen Sie Ihren Mandanten für die Funktionsentwicklung einrichten und Ihre Funktionsentwicklungsumgebung einrichten.

Wenn Sie eine Anwendung in Oracle Functions definieren, geben Sie die Subnetze an, in denen die Funktionen in der Anwendung ausgeführt werden sollen. Außerdem geben Sie an, ob das Logging für die Funktionen in der Anwendung aktiviert werden soll.

Melden Sie sich als Funktionsentwickler bei der Konsole an.
Öffnen Sie in der Konsole das Navigationsmenü. Gehen Sie unter Lösungen und Plattform zu Developer Services, und klicken Sie auf Funktionen.
Wählen Sie die Region, die Sie mit Oracle Functions verwenden. Oracle empfiehlt, dass Sie denselben Bereich wie die Docker-Registry verwenden, die im Fn Project CLI-Kontext angegeben ist.
Wählen Sie das Compartment, das im Fn-Projekt-CLI-Kontext angegeben ist. Auf der Seite "Anwendungen" werden die Anwendungen angezeigt, die bereits im Compartment definiert sind.
Klicken Sie auf Anwendung erstellen und geben Sie Folgendes an:
- Name: Ein Name der neuen Anwendung. Geben Sie dabei keine vertraulichen Informationen ein.
- VCN und Subnetz: VCN und Subnetz, in dem Funktionen ausgeführt werden sollen.
Klicken Sie auf Erstellen.

Die neue Anwendung wird in der Liste der Anwendungen angezeigt.

Automatisierungsfunktion erstellen und bereitstellen

Erstellen, bereitstellen und konfigurieren Sie die Funktion loadziptojson in der Anwendung ocijsonpub.

Initialisieren der Funktion:
```
 fn init --runtime python loadziptojson
```
Ein Verzeichnis wird mit dem angegebenen Funktionsnamen erstellt, der func.py, func.yaml und requirements.txt-Dateien enthält. Die Datei func.yaml enthält die Mindestanzahl an Informationen, die zum Erstellen und Ausführen der Funktion erforderlich sind.

Öffnen Sie func.py, und ersetzen Sie den Inhalt durch die folgenden Codeblöcke:

Importieren Sie die erforderlichen Python-Module:

import io
import json
import oci
import csv
import requests
import traceback
from io import StringIO
from io import BytesIO
 
from zipfile import ZipFile, is_zipfile
from fdk import responsecode

Definieren Sie einen Funktions-Handler, um die Datei zu entpacken und in die JSON-Datenbank einzufügen, wenn die Datei in den Objektspeicher hochgeladen wird:

def handler(ctx, data: io.BytesIO=None):
    signer = oci.auth.signers.get_resource_principals_signer()
 
    object_name = bucket_name = namespace = ordsbaseurl = schema = dbuser = dbpwd = ""
    try:
        cfg = ctx.Config()
        input_bucket = cfg["inputbucket"]
        processed_bucket = cfg["processedbucket"]
        ordsbaseurl = cfg["ordsbaseurl"]
        schema = cfg["dbschema"]
        dbuser = cfg["dbuser"]
        dbpwd = cfg["dbpwd"]
    except Exception as e:
        print('Missing function parameters: bucket_name, ordsbaseurl, schema, dbuser, dbpwd', flush=True)
        raise
    try:
        body = json.loads(data.getvalue())
        object_name = body["data"]["resourceName"]
        if body["data"]["additionalDetails"]["bucketName"] != input_bucket:
            raise ValueError("Event Bucket name error")
        namespace = body["data"]["additionalDetails"]["namespace"]
    except Exception as e:
        print('ERROR: bad Event!', flush=True)
        raise
    try:   
        insert_status = load_data(signer, namespace, input_bucket, object_name, ordsbaseurl, schema, dbuser, dbpwd)
        #move_object(signer, namespace, input_bucket, processed_bucket, object_name)
 
        return response.Response(
           ctx,
           response_data=json.dumps(insert_status),
           headers={"Content-Type": "application/json"}
        )
    except Exception as e:
        return response.Response(
            ctx, response_data=json.dumps([{'Error': traceback.format_exc()}
                                          , ]),
            headers={"Content-Type": "application/json"}
        )

Definieren Sie eine Dataload-Funktion, die von der Handler-Funktion aufgerufen wird, um die Datei zu entpacken, lesen Sie die Datei csv in der Datei zip, und schleifen Sie zeilenweise durch, um die Funktion soda_insert aufzurufen.

def load_data(signer, namespace, bucket_name, object_name, ordsbaseurl, schema, dbuser, dbpwd):
    client = oci.object_storage.ObjectStorageClient(config={}, signer=signer)
    zipfile = client.get_object(namespace, bucket_name, object_name)
    insert_status = {}
 
    if zipfile.status == 200:
       print("INFO - Object {0} is read".format(object_name), flush=True)
       #object_storage_client.get_object
 
       with ZipFile(BytesIO(zipfile.data.content)) as zippy:
          for item in zippy.infolist():
             print(item.filename, flush=True)
             try:
                 if not 'MACOS' in item.filename and 'csv' in item.filename:
                    csvdata = csv.DictReader(zippy.read(item.filename).decode('utf-8').split('\n'),delimiter=',')
                    for row in csvdata:
                       insert_status = soda_insert(ordsbaseurl, schema, dbuser, dbpwd, dict(row))
             except Exception:
                 print('trouble decoding the file ', flush=True)
                 continue
  
        
    else:
         raise SystemExit("cannot retrieve the object" + str(object_name))
    return insert_status

Definieren Sie eine Einfügefunktion, die die Sammlung erstellt und Daten in die Sammlung einfügt.

def soda_insert(ordsbaseurl, schema, dbuser, dbpwd, document):
   
    auth=(dbuser, dbpwd)
    sodaurl = ordsbaseurl + schema + '/soda/latest/'
    collectionurl = sodaurl + "censusdata"
 
    headers = {'Content-Type': 'application/json'}
    print("INFO - calling SODA with requests:", flush=True)
    print("INFO - before calling SODA :dbuser : "+dbuser, flush=True)
    print("INFO - before calling SODA :dbpwd : "+dbpwd, flush=True)
    reqjson={}
    r = requests.put(collectionurl, auth=auth, headers=headers, data=reqjson)
    print("INFO - before calling SODA :document : "+json.dumps(document), flush=True)
    i = requests.post(collectionurl, auth=auth, headers=headers, data=json.dumps(document))
 
    r_json = {}
    r_json = json.dumps(r.text)
    return r_json

Öffnen Sie func.yaml, und ersetzen Sie den Inhalt durch Folgendes:

schema_version: 20180708
name: loadziptojson
version: 0.0.31
runtime: python
entrypoint: /python/bin/fdk /function/func.py handler
memory: 256

Öffnen Sie requirements.txt, und ersetzen Sie den Inhalt durch Folgendes:
```
fdk
oci
requests
```
Geben Sie den folgenden einzelnen Fn Project-Befehl ein, um die Funktion und ihre Abhängigkeiten als Docker-Image zu erstellen, das Image in die angegebene Docker-Registry zu pushen und die Funktion in Oracle Functions in der angegebenen Anwendung bereitzustellen:
```
fn -v deploy --app ocijsonpub
```

Funktionsparameter mit folgendem Format konfigurieren:

$ fn config function <application_name> <function_name> --<property> <value>

Beispiel: Konfigurieren Sie die Funktion ocijsonpub mit den folgenden Anweisungen, indem Sie die erforderlichen Werte ersetzen, sofern angegeben:

#Autonomous Database schema
fn config function ocijsonpub loadziptojson dbschema <db_schema>
#Autonomous Database Username
fn config function ocijsonpub loadziptojson dbuser <db_user_name>
#Autonomous Database password
fn config function ocijsonpub loadziptojson dbpwd <db_password>
# Object storage bucket for input file
fn config function ocijsonpub loadziptojson inputbucket <input_files_bucket>
# Object storage bucket to archive the zip file after processing
fn config function ocijsonpub loadziptojson processedbucket <processed_files_bucket>