Azure Function en Python

La plataforma cloud de Azure ofrece un servicio para definir funciones, el servicio se llama “Function App”. Las funciones permiten definir funciones para la construcción de arquitecturas Serverless. Las funciones pueden ser definidas en distintos lenguajes, como pueden ser: Java, Python, F#, C#,… En la presente entrada, Azure Function en Python, me centraré en cómo crear funciones Python y su despliegue en Azure.

La estructura de la entrada es la siguiente:

  1. Instalación de Azure Functions Tools
    • Creación del proyecto
    • Creación de una función
    • Ficheros de configuración
  2. Función Functionbase
  3. Función Functionstore
  4. Ejecución de las funciones en local
  5. Publicación en Azure

Azure no proporciona un intarfaz en donde se puede desarrollar una función, es necesario  crear un entorno con unas herramientas determinadas, desarrollar la función y, una vez creada, se realiza el despliegue a la plataforma.

Para definir funciones en Azure es necesario realizar las siguientes tareas en un entorno local:

  1. Instalar el paquete Azure Functions Tools.
  2. Desarrollar en local la función.
  3. Desplegar el código en Azure.

1.- Instalación de Azure Functions Tools.

Azure Functions Tools es un conjunto de herramientas para el desarrollo de funciones en Python. En mi caso, al ser un entorno Linux, necesito ejecutar la siguiente secuencia de comandos:

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-$(lsb_release -cs)-prod $(lsb_release -cs) main" > /etc/apt/sources.list.d/dotnetdev.list'
sudo apt-get update
sudo apt-get install azure-functions-core-tools
sudo apt-get install python3-venv

La versión de Python es la versión 3.6 y, para asegurar la creación de entornos virtuales, he ejecutado el comando de instalación del paquete python3-venv.

Para asegurar que el paquete se ha instalado correctamente, podemos ejecutar en la línea de comandos el comando func -h; el resultado, es la visualización de la ayuda del comando.

Creación del proyecto

La creación de un proyecto consiste en la creación de una estructura de directorios con los elementos necesarios para poder trabajar. El comando de creación del proyecto es el
siguiente:

func init MyFunctionProj

Una vez ejecutado, se tendrá que seleccionar el lenguaje del proyecto, en nuestro caso, opción 3 Python y se creará un directorio con nombre MyFunctionProj con los elementos necesarios para poder trabajar. El contenido de la carpeta será el siguiente:

  • host.json.- Fichero JSON de configuración de extensiones y confuguración.
  • local.settings.json.- Fichero con la configuración de acceso a los servicios Azure.
  • requirements.txt.- Fichero con las dependencias de Python.

Creación de una función

Para realizar la creación de una función, desde la línea de comandos, nos ubicaremos en la carpeta raíz del proyecto; y, una vez allí, ejecutamos el siguiente comando:

func new

El comando nos obliga a seleccionar una plantilla de función entre las nueve existentes las cuáles son:

Select a template:
1. Azure Blob Storage trigger
2. Azure Cosmos DB trigger
3. Azure Event Grid trigger
4. Azure Event Hub trigger
5. HTTP trigger
6. Azure Queue Storage trigger
7. Azure Service Bus Queue trigger
8. Azure Service Bus Topic trigger
9. Timer trigger
Choose option:

Llegado a este punto es necesario realizar una parada para definir el significado del concepto de trigger. Un trigger es aquel elemento que permite desencadenar el funcionamiento de una función; un ejemplo de trigger, es una petición HTTP, es decir, cuando se realiza una petición HTTP se inicia la ejecución de una función; otro tipo de trigger puede ser Blob Storage Trigger, es aquel desencadenador que ejecuta una función por la existencia de un fichero en un blob determinado. De los posibles desencadenadores tenemos los siguiente tipos: HTTP, Cosmos DB, Blob Storage, un Timer, Event Grid, Event Hub, Service Bus Queue, Service Bus topic y Queue Storage. Una vez seleccionado el tipo, se deberá de informar del nombre de la función.

Los ejemplos que describiré son dos funciones:

  1. FunctionBase.- Función sencilla con desencadenador HTTP
  2. FunctionStore.- Función con desencadenador HTTP, un Blob Storage de entrada y otro de salida para realizar lecturas y escrituras en un Store de Azure.

La creación de cada función realiza la creación de un directorio con dos ficheros los cuáles son los siguientes:

  • __init__.py.- Fichero con el código Python de la función.
  • function.json.- Fichero con la configuración de la función: definición del desencadenador binding, route, nombre de la función a ejecutar en el fichero __init__.py

La estructura del proyecto con las dos funciones y los ficheros de configuración tiene un aspecto como el siguiente:

__app__
| - FunctionBase
| | - __init__.py
| | - function.json
| - FunctionStore
| | - __init__.py
| | - function.json
| - host.json
| - local.settings.json
| - requirements.txt
tests

Ficheros de configuración

  • host.json.- Fichero con la configuración de las funciones. El contenido es el siguiente:
{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[1.*, 2.0.0)"
  }
}
  • local.settings.json.- Fichero con las conexiones a los servicios de Azure.
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "AzureWebJobsStorage": "<CONNECTION_STRING>",
    "FUNCTIONS_EXTENSION_VERSION": "~2",
    "APPINSIGHTS_INSTRUMENTATIONKEY": "a66ab777-1fa1-222c-3333-4e44d4c4444f"
  },
  "ConnectionStrings": {}
}
  • requirements.txt.- Definición de las dependencias de las librerías Python.
azure-functions
azure-functions-worker
azure-storage-blob
azure-cosmos
azure-storage
azure-storage-blob
pillow>=6.2.0

Para ejecutar el entorno virtual local desde la carpeta del proyecto en una consola, ejecutamos la siguiente secuencia de comandos:

virtualenv .venv -p python3
source .venv/bin/activate
pip install -r requirements.txt

2.- Función Functionbase

La función FunctionBase es una función sencilla que realiza la definición de un desencadenador de tipo HTTP y, su salida, es una respuesta HTTP. Realiza la lectura de petición HTTP y responde en función de los parámetros de entrada.

El contenido del fichero function.json es el siguiente:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}

Del snippet anterior hay que destacar lo siguiente:

  • El elemento “scriptFile” define el fichero con el código de la función.
  • El elemento “type” define el tipo de elemento, en nuestro caso, trigger de tipo HTTP o HTTP.
  • El elemento “direction” determina si es de entrada o de salida.
  • El elemento “name” identifica la referencia en el código.
  • El elemento “methods” identifica los métodos HTTP que define la función, en nuestro caso, GET o POST.

El contenido del fichero __init__.py es el siguiente:

import logging
import azure.functions as func
from datetime import datetime
def main(req: func.HttpRequest) -> func.HttpResponse:
  """
  + curl -v -w '\n' -d '{"name":"pp"}' -H 'DateData: 2019/11/26' -H 'Content-Type: application/json' -X POST http://localhost:7071/api/FunctionBase
  + curl -v -w '\n' -d '{"name":"pp"}' -H 'DateData: 2019/11/26' -H 'Content-Type: application/json' -X POST https://<URL-AZURE>.net/api/FunctionBase?code=<FUNCTION_KEY>
  """
  logging.info('Python HTTP trigger function processed a request.')
  datetime_object = datetime.strptime(req.headers.get('DateData'), '%Y/%m/%d')
  name = req.params.get('name')
  if not name:
    try:
      req_body = req.get_json()
    except ValueError:
      pass
  else:
    name = req_body.get('name')
  if name:
    return func.HttpResponse('{ "test": "' + name + '", "date": "' + str(datetime_object) + '"}')
  else:
    return func.HttpResponse(
      "Please pass a name on the query string or in the request body", status_code=400)

El código define una función main que recibe la referencia de la petición HTTP, realiza un procesamiento conforme a los parámetros de entrada y, por último, crea la respuesta.

3.- Función  Functionstore

La función FunctioStore realiza el copiado de un fichero en un Store de Azure cuyo nombre es pasado en una petición HTTP.

El contenido del fichero function.json es el siguiente:

{
  "disabled": false,
  "scriptFile": "__init__.py",
  "bindings": [
  {
    "authLevel": "function",
    "type": "httpTrigger",
    "direction": "in",
    "name": "request",
    "methods": [
      "get",
      "post"
    ],
    "route": "FunctionStore/{name:alpha?}"
  },
  {
    "name": "inputblob",
    "type": "blob",
    "path": "staging/{name}.png",
    "connection": "AzureWebJobsStorage",
    "direction": "in"
  },
  {
    "name": "blobout",
    "type": "blob",
    "direction": "out",
    "path": "staging/{name}-copy.txt",
    "connection": "AzureWebJobsStorage"
  },
  {
    "type": "http",
    "direction": "out",
    "name": "$return"
  }
 ]
}

En el código anterior y partiendo de la primera función, se añaden los dos blob de lectura y escritura, respectivamente, inputblob y outputblob. El elemento “path”, corresponde con el path de la ubicación de los ficheros; el elemento “type”, corresponde con el tipo blob; el elemento “connection”, corresponde con la referencia a la conexión del blob; y, un detalle importante es el elemento “route”, define el nombre del fichero pasado en la URL de la petición y dicho parámetro es usado en los blob de entrada y salida para referenciar el nombre del fichero de lectura y  de escritura.

El contenido del fichero con el código Python es el siguiente:

import logging
import azure.functions as func
from datetime import datetime
def main(request: func.HttpRequest, inputblob: func.InputStream, blobout: func.Out[func.InputStream], context: func.Context) -> func.HttpResponse:
  """
  curl -v -w '\n' -H 'DateData: 2019/11/26' -d '{ "param1": "value1", "param2": "value2" }' -X GET http://localhost:7071/api/FunctionStore/watermark?name=11
  """
  logging.info('Python HTTP trigger function processed a request.')
  logging.info(f'context.function_directory={context.function_directory}.')
  logging.info(f'context.function_name={context.function_name}.')
  logging.info(f'context.invocation_id={context.invocation_id}.')
  logging.info(f"Params: {request.params}")
  logging.info(f"Route Params: {request.route_params}")
  logging.info(f"Body: {request.get_body()}")
  logging.info(f"Headers: {request.headers}")
  logging.info(f"Headers: {request.headers.get('DateData')}")
  datetime_object = datetime.strptime(request.headers.get('DateData'), '%Y/%m/%d')
  logging.info(f"Fecha: {datetime_object}")
  name = datetime_object
  if not name:
    try:
      req_body = request.get_json()
    except ValueError:
      pass
  else:
    name = req_body.get('name')
  blobout.set(inputblob)
  if name:
    return func.HttpResponse(f"Hello {name}!")
  else:
    return func.HttpResponse(
      "Please pass a name on the query string or in the request body",status_code=400)

Del código anterior, destaca la siguiente línea: blobout.set(inputblob) ; ésta línea, realiza la lectura del fichero definido en inputblob y su copiado en blobout. El resto del código es la visualización de los parámetros de la petición HTTP y su tratamiento.

4.- Ejecución de las funciones en local

Para ejecutar las funciones en un entorno local es necesario ejecutar desde la carpeta del proyecto el siguiente comando:

func host start

Para ejecutar las funciones ejecutamos el comando curl desde la línea de comandos. Respectivamente, para la función base y Store, ejecutamos los siguientes comandos:

curl -v -w '\n' -d '{"name":"pp"}' -H 'DateData: 2019/11/26' -H 'Content-Type: application/json' -X POST http://localhost:7071/api/FunctionBase
curl -v -w '\n' -H 'DateData: 2019/11/26' -d '{ "param1": "value1", "param2": "value2" }' -X GET http://localhost:7071/api/FunctionStore/watermark?name=11

5.- Publicación en Azure

Para realizar el despliegue, es necesario crear una función en Azure. El código Python será el código del proyecto. El proceso de creación es sencillo desde el portal de Azure,  simplemente, hay que seleccionar el grupo de recurso, lenguaje, nombre,…

Una vez que la tengamos creada, desde la línea de comando realizaremos la operación de login con el comando “az login” y, una vez logueado, ejecutamos el comando de despliegue el cuál es el siguiente:func azure functionapp publish <APP_NAME>. Para nuestro caso, si la Function App tiene nombre MyFunctionProj el comando es el siguiente:

func azure functionapp publish MyFunctionProj

Para realizar las pruebas, se puede utilizar el comando curl, Postman o el propio interfaz de pruebas que proporciona Azure.

En la siguiente imagen, realizo un resumen de la entrada de los apartados anteriores representados como un sketchnoting.

 

Si el lector está interesado en el código, lo puede encontrar en el siguiente enlace.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google photo

Estás comentando usando tu cuenta de Google. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s