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.

  1. Melden Sie sich als Funktionsentwickler bei der Konsole an.
  2. Öffnen Sie in der Konsole das Navigationsmenü. Gehen Sie unter Lösungen und Plattform zu Developer Services, und klicken Sie auf Funktionen.
  3. 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.
  4. 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.
  5. 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.
  6. 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.

  1. 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.

  2. Öffnen Sie func.py, und ersetzen Sie den Inhalt durch die folgenden Codeblöcke:
    1. 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
    2. 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"}
              )
    3. 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
    4. 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
  3. Ö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
  4. Öffnen Sie requirements.txt, und ersetzen Sie den Inhalt durch Folgendes:
    fdk
    oci
    requests
  5. 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
  6. 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>