Crear Automatización

Cree e implemente la función de automatización y aplicación.

Crear Aplicación Oracle Functions

Una aplicación es una agrupación lógica de funciones que permite asignar y configurar recursos para todo el grupo y aislar las funciones durante el tiempo de ejecución.

Antes de poder crear la aplicación, debe configurar su arrendamiento para el desarrollo de funciones y debe configurar su entorno de desarrollo de funciones.

Al definir una aplicación en Oracle Functions, debe especificar las subredes en las que ejecutar las funciones de la aplicación. También puede especificar si se debe activar el registro para las funciones de la aplicación.

Conéctese a la consola como desarrollador de funciones.
En la consola, abra el menú de navegación. En Soluciones y Plataforma, vaya a Servicios para desarrolladores y haga clic en Funciones.
Seleccione la región que utiliza con Oracle Functions. Oracle recomienda utilizar la misma región que el registro de Docker especificado en el contexto de la CLI de Fn Project.
Seleccione el compartimento especificado en el contexto de la CLI de Fn Project. La página Aplicaciones muestra las aplicaciones ya definidas en el compartimento.
Haga clic en Crear Aplicación y especifique:
- Nombre: nombre para la nueva aplicación. Evite introducir información confidencial.
- VCN y subred: VCN y subred en las que ejecutar funciones.
Haga clic en Crear.

La nueva aplicación aparece en la lista de aplicaciones.

Creación y despliegue de la función de automatización

Cree, despliegue y configure la función loadziptojson en la aplicación ocijsonpub.

Inicializa la función:
```
 fn init --runtime python loadziptojson
```
Se crea un directorio con el nombre de función especificado, que contiene archivos func.py, func.yaml y requirements.txt. El archivo func.yaml contiene la cantidad mínima de información necesaria para crear y ejecutar la función.

Abra func.py y sustituya el contenido por los siguientes bloques de código:

Importe los módulos de Python necesarios:

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

Defina un manejador de funciones para descomprimir el archivo e insertarlo en la base de datos JSON cuando se carga el archivo en el almacenamiento de objetos:

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"}
        )

Defina una función de carga de datos a la que llama la función de manejador para descomprimir el archivo, leer el archivo csv que está en el archivo zip y bucles a través de línea por línea para llamar a la función soda_insert.

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

Defina una función de inserción que cree la recopilación e inserte datos en la recopilación.

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

Abra func.yaml y sustituya el contenido por el siguiente:

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

Abra requirements.txt y sustituya el contenido por el siguiente:
```
fdk
oci
requests
```
Introduzca el siguiente comando Fn Project único para crear la función y sus dependencias como imagen Docker, empuje la imagen al registro Docker especificado y despliegue la función en Oracle Functions en la aplicación especificada:
```
fn -v deploy --app ocijsonpub
```

Configurar parámetros de función con el siguiente formato:

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

Por ejemplo, configure la función ocijsonpub mediante las siguientes sentencias, sustituyendo los valores necesarios cuando se indique lo siguiente:

#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>