Créer l'automatisation

Créer et déployer la fonction d'application et d'automatisation.

Créer l'application Oracle Functions

Une application est un regroupement logique de fonctions qui vous permet d'allouer et de configurer des ressources pour l'ensemble du groupe et d'isoler les fonctions pendant l'exécution.

Pour pouvoir créer l'application, vous devez configurer la location pour le développement de fonctions et configurer l'environnement de développement de fonctions.

Lorsque vous définissez une application dans Oracle Functions, indiquez les sous-réseaux dans lesquels exécuter les fonctions dans l'application. Vous devez également indiquer si la journalisation doit être activée pour les fonctions de l'application.

Connectez-vous à la console en tant que développeur de fonctions.
Dans la console, ouvrez le menu de navigation. Sous Solutions et plate-forme, accédez à Services de développeur et cliquez sur Fonctions.
Sélectionnez la région que vous utilisez avec Oracle Functions. Oracle recommande d'utiliser la même région que le registre Docker spécifié dans le contexte de la CLI Projet Fn.
Sélectionnez le compartiment spécifié dans le contexte CLI Projet Fn. La page Applications affiche les applications déjà définies dans le compartiment.
Cliquez sur Créer une application et indiquez :
- Nom : nom de la nouvelle application. Evitez de saisir des informations confidentielles.
- VCN et sous-réseau : VCN et sous-réseau dans lesquels exécuter des fonctions.
Cliquez sur Créer.

La nouvelle application apparaît dans la liste des applications.

Créer et déployer la fonction d'automatisation

Créez, déployez et configurez la fonction loadziptojson dans l'application ocijsonpub.

Initialiser la fonction :
```
 fn init --runtime python loadziptojson
```
Un répertoire est créé avec le nom de fonction que vous avez indiqué, contenant les fichiers func.py, func.yaml et requirements.txt. Le fichier func.yaml contient la quantité minimale d'informations requises pour créer et exécuter la fonction.

Ouvrez func.py et remplacez le contenu par les blocs de code suivants :

Importez les modules Python nécessaires :

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

Définissez un gestionnaire de fonctions pour décompresser le fichier et insérer dans la base de données JSON lorsque le fichier est téléchargé vers le stockage d'objet :

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

Définissez une fonction de chargement de données que la fonction de gestionnaire appelle pour décompresser le fichier, lisez le fichier csv qui se trouve dans le fichier zip et bouclez ligne par ligne pour appeler la fonction 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

Définissez une fonction d'insertion qui crée la collecte et insère des données dans la collection.

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

Ouvrez func.yaml et remplacez le contenu par ce qui suit :

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

Ouvrez requirements.txt et remplacez le contenu par ce qui suit :
```
fdk
oci
requests
```
Entrez la commande Fn Project suivante pour créer la fonction et ses dépendances en tant qu'image Docker, poussez l'image vers le registre Docker spécifié et déployez la fonction vers Oracle Functions dans l'application spécifiée :
```
fn -v deploy --app ocijsonpub
```

Configurez les paramètres de fonction au format suivant :

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

Par exemple, configurez la fonction ocijsonpub à l'aide des instructions suivantes, en remplaçant les valeurs obligatoires lorsque cela est indiqué :

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