Guía de Azure Functions para desarrolladores de PythonAzure Functions Python developer guide

Este artículo es una introducción al desarrollo de Azure Functions mediante Python.This article is an introduction to developing Azure Functions using Python. En lo que va a leer a continuación se supone que ya ha leído la guía para desarrolladores de Azure Functions.The content below assumes that you've already read the Azure Functions developers guide.

Para ver los proyectos de ejemplo de funciones independientes de Python, examine los ejemplos de funciones de Python.For standalone Function sample projects in Python, see the Python Functions samples.

Modelo de programaciónProgramming model

Azure Functions espera que una función sea un método sin estado de un script de Python que procese entradas y genere salidas.Azure Functions expects a function to be a stateless method in your Python script that processes input and produces output. De forma predeterminada, el runtime espera que el modelo se implemente como un método global denominado main() en el archivo __init__.py.By default, the runtime expects the method to be implemented as a global method called main() in the __init__.py file. También puede especificar un punto de entrada alternativo.You can also specify an alternate entry point.

Los datos de los desencadenadores y enlaces se enlazan a la función a través de los atributos del método con la propiedad name definida en el archivo function.json.Data from triggers and bindings is bound to the function via method attributes using the name property defined in the function.json file. Por ejemplo, en el archivo function.json siguiente se describe una función simple desencadenada por una solicitud HTTP denominada req:For example, the function.json below describes a simple function triggered by an HTTP request named req:

{
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous"
    },
    {
      "name": "$return",
      "direction": "out",
      "type": "http"
    }
  ]
}

El archivo __init__.py contiene el código de función siguiente:The __init__.py file contains the following function code:

def main(req):
    user = req.params.get('user')
    return f'Hello, {user}!'

también puede declarar explícitamente los tipos de parámetros y el tipo de valor devuelto de la función mediante las anotaciones de tipos de Python.you can also explicitly declare the attribute types and return type in the function using Python type annotations. Esto le ayuda a usar las características de IntelliSense y Autocompletar proporcionadas por muchos editores de código de Python.This helps you use the intellisense and autocomplete features provided by many Python code editors.

import azure.functions


def main(req: azure.functions.HttpRequest) -> str:
    user = req.params.get('user')
    return f'Hello, {user}!'

Utilice las anotaciones de Python incluidas en el paquete azure.functions.* para enlazar las entradas y las salidas a los métodos.Use the Python annotations included in the azure.functions.* package to bind input and outputs to your methods.

Punto de entrada alternativoAlternate entry point

Puede cambiar el comportamiento predeterminado de una función si especifica opcionalmente las propiedades scriptFile y entryPoint en el archivo function.json.You can change the default behavior of a function by optionally specifying the scriptFile and entryPoint properties in the function.json file. Por ejemplo, el archivo function.json siguiente indica al runtime que use el método customentry() del archivo main.py, como punto de entrada para la instancia de Azure Functions.For example, the function.json below tells the runtime to use the customentry() method in the main.py file, as the entry point for your Azure Function.

{
  "scriptFile": "main.py",
  "entryPoint": "customentry",
  "bindings": [
      ...
  ]
}

Estructura de carpetasFolder structure

La estructura de carpetas recomendada para un proyecto de Python en Azure Functions tiene la siguiente apariencia:The recommended folder structure for a Python Functions project looks like the following example:

 __app__
 | - MyFirstFunction
 | | - __init__.py
 | | - function.json
 | | - example.py
 | - MySecondFunction
 | | - __init__.py
 | | - function.json
 | - SharedCode
 | | - myFirstHelperFunction.py
 | | - mySecondHelperFunction.py
 | - host.json
 | - requirements.txt
 tests

La carpeta de proyecto principal (__app__) puede contener los siguientes archivos:The main project folder (__app__) can contain the following files:

  • local.settings.json: se usa para almacenar la configuración y las cadenas de conexión de la aplicación cuando se ejecuta localmente.local.settings.json: Used to store app settings and connection strings when running locally. Este archivo no se publica en Azure.This file doesn't get published to Azure. Para más información, consulte local.settings.file.To learn more, see local.settings.file.
  • requirements.txt: contiene la lista de paquetes que se instalan al publicar en Azure.requirements.txt: Contains the list of packages the system installs when publishing to Azure.
  • host.json: contiene las opciones de configuración global que afectan a todas las funciones de una aplicación de funciones.host.json: Contains global configuration options that affect all functions in a function app. Este archivo se publica en Azure.This file does get published to Azure. No todas las opciones se admiten cuando se ejecuta localmente.Not all options are supported when running locally. Para más información, consulte host.json.To learn more, see host.json.
  • funcignore: (opcional) declara los archivos que no deben publicarse en Azure.funcignore: (Optional) declares files that shouldn't get published to Azure.
  • gitignore: (opcional) declara los archivos que se excluyen de un repositorio de Git, como local.settings.json.gitignore: (Optional) declares files that are excluded from a git repo, such as local.settings.json.

Cada función tiene su propio archivo de código y archivo de configuración de enlace (function.json).Each function has its own code file and binding configuration file (function.json).

El código compartido debe mantenerse en una carpeta independiente en __app__.Shared code should be kept in a separate folder in __app__. Para hacer referencia a los módulos en la carpeta SharedCode, puede usar la sintaxis siguiente:To reference modules in the SharedCode folder, you can use the following syntax:

from __app__.SharedCode import myFirstHelperFunction

Para hacer referencia a los módulos locales de una función, puede usar la sintaxis de importación relativa de la siguiente manera:To reference modules local to a function, you can use the relative import syntax as follows:

from . import example

Al implementar el proyecto en una aplicación de funciones de Azure, debe incluirse en el paquete todo el contenido de la carpeta FunctionApp, pero no la propia carpeta.When deploying your project to a function app in Azure, the entire content of the FunctionApp folder should be included in the package, but not the folder itself. Se recomienda mantener las pruebas en una carpeta independiente de la carpeta del proyecto; en este ejemplo tests.We recommend that you maintain your tests in a folder separate from the project folder, in this example tests. Esto evita que se implemente código de prueba con la aplicación.This keeps you from deploying test code with your app. Para más información, consulte Pruebas unitarias.For more information, see Unit Testing.

Desencadenadores y entradasTriggers and Inputs

Las entradas se dividen en dos categorías dentro de Azure Functions: una entrada del desencadenador y otra adicional.Inputs are divided into two categories in Azure Functions: trigger input and additional input. Aunque son diferentes en el archivo function.json, se usan igual en el código de Python.Although they are different in the function.json file, usage is identical in Python code. Las cadenas de conexión o los secretos de los orígenes de entrada y el desencadenador se asignan a valores en el archivo local.settings.json al ejecutarse localmente y a la configuración de la aplicación al ejecutarse en Azure.Connection strings or secrets for trigger and input sources map to values in the local.settings.json file when running locally, and the application settings when running in Azure.

Por ejemplo, el siguiente código muestra la diferencia entre las dos:For example, the following code demonstrates the difference between the two:

// function.json
{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous",
      "route": "items/{id}"
    },
    {
      "name": "obj",
      "direction": "in",
      "type": "blob",
      "path": "samples/{id}",
      "connection": "AzureWebJobsStorage"
    }
  ]
}
// local.settings.json
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "python",
    "AzureWebJobsStorage": "<azure-storage-connection-string>"
  }
}
# __init__.py
import azure.functions as func
import logging


def main(req: func.HttpRequest,
         obj: func.InputStream):

    logging.info(f'Python HTTP triggered function processed: {obj.read()}')

Cuando se invoca la función, la solicitud HTTP se pasa a la función como req.When the function is invoked, the HTTP request is passed to the function as req. Se recuperará una entrada de Azure Blob Storage según el identificador de la dirección URL de la ruta y estará disponible como obj en el cuerpo de la función.An entry will be retrieved from the Azure Blob Storage based on the ID in the route URL and made available as obj in the function body. Aquí, la cuenta de almacenamiento especificada es la cadena de conexión encontrada, que es la misma cuenta de almacenamiento que usa la aplicación de funciones.Here the storage account specified is the connection string found in , which is the same storage account used by the function app.

SalidasOutputs

Las salidas se pueden expresar como valores devueltos y como parámetros de salida.Output can be expressed both in return value and output parameters. Si hay una única salida, se recomienda usar el valor devuelto.If there's only one output, we recommend using the return value. Para varias salidas, deberá utilizar parámetros de salida.For multiple outputs, you'll have to use output parameters.

Para usar el valor devuelto de una función como valor de un enlace de salida, la propiedad name del enlace debe establecerse como $return en function.json.To use the return value of a function as the value of an output binding, the name property of the binding should be set to $return in function.json.

Si desea generar varias salidas, utilice el método set() que la interfaz azure.functions.Out ofrece para asignar un valor al enlace.To produce multiple outputs, use the set() method provided by the azure.functions.Out interface to assign a value to the binding. Por ejemplo, la siguiente función puede insertar un mensaje en una cola y también devolver una respuesta HTTP.For example, the following function can push a message to a queue and also return an HTTP response.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "req",
      "direction": "in",
      "type": "httpTrigger",
      "authLevel": "anonymous"
    },
    {
      "name": "msg",
      "direction": "out",
      "type": "queue",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    },
    {
      "name": "$return",
      "direction": "out",
      "type": "http"
    }
  ]
}
import azure.functions as func


def main(req: func.HttpRequest,
         msg: func.Out[func.QueueMessage]) -> str:

    message = req.params.get('body')
    msg.set(message)
    return message

RegistroLogging

El acceso al registrador del entorno de ejecución de Azure Functions está disponible a través de un controlador logging raíz en la aplicación de función.Access to the Azure Functions runtime logger is available via a root logging handler in your function app. Este registrador está asociado a Application Insights y permite marcar las advertencias y los errores detectados durante la ejecución de la función.This logger is tied to Application Insights and allows you to flag warnings and errors encountered during the function execution.

En el ejemplo siguiente se registra un mensaje de información cuando la función se invoca con un desencadenador HTTP.The following example logs an info message when the function is invoked via an HTTP trigger.

import logging


def main(req):
    logging.info('Python HTTP trigger function processed a request.')

Hay métodos de registro adicionales disponibles que permiten escribir en la consola en otros niveles de seguimiento:Additional logging methods are available that let you write to the console at different trace levels:

MétodoMethod DESCRIPCIÓNDescription
critical(_message_) Escribe un mensaje con el nivel CRÍTICO en el registrador de raíz.Writes a message with level CRITICAL on the root logger.
error(_message_) Escribe un mensaje con el nivel ERROR en el registrador de raíz.Writes a message with level ERROR on the root logger.
warning(_message_) Escribe un mensaje con el nivel ADVERTENCIA en el registrador de raíz.Writes a message with level WARNING on the root logger.
info(_message_) Escribe un mensaje con el nivel INFO en el registrador de raíz.Writes a message with level INFO on the root logger.
debug(_message_) Escribe un mensaje con el nivel DEBUG en el registrador de raíz.Writes a message with level DEBUG on the root logger.

Para más información sobre el registro, consulte Supervisión de Azure Functions.To learn more about logging, see Monitor Azure Functions.

Desencadenadores y enlaces HTTPHTTP Trigger and bindings

El desencadenador HTTP se define en el archivo function.json.The HTTP trigger is defined in the function.jon file. El valor de name del enlace debe coincidir con el parámetro con nombre de la función.The name of the binding must match the named parameter in the function. En los ejemplos anteriores, se usa un nombre de enlace req.In the previous examples, a binding name req is used. Este parámetro es un objeto HttpRequest y se devuelve un objeto HttpResponse.This parameter is an HttpRequest object, and an HttpResponse object is returned.

Desde el objeto HttpRequest, puede obtener encabezados de solicitud, parámetros de consulta, parámetros de ruta y el cuerpo del mensaje.From the HttpRequest object, you can get request headers, query parameters, route parameters, and the message body.

El ejemplo siguiente es de la plantilla de desencadenador HTTP para Python.The following example is from the HTTP trigger template for Python.

def main(req: func.HttpRequest) -> func.HttpResponse:
    headers = {"my-http-header": "some-value"}

    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(f"Hello {name}!", headers=headers)
    else:
        return func.HttpResponse(
             "Please pass a name on the query string or in the request body",
             headers=headers, status_code=400
        )

En esta función, el valor del parámetro de consulta name se obtiene del parámetro params del objeto HttpRequest.In this function, the value of the name query parameter is obtained from the params parameter of the HttpRequest object. El cuerpo del mensaje con codificación JSON se lee mediante el método get_json.The JSON-encoded message body is read using the get_json method.

Del mismo modo, puede establecer status_code y headers para el mensaje de respuesta en el objeto HttpResponse devuelto.Likewise, you can set the status_code and headers for the response message in the returned HttpResponse object.

SimultaneidadConcurrency

De forma predeterminada, el tiempo de ejecución de Python de Functions solo puede procesar una invocación de función a la vez.By default, the Functions Python runtime can only process one invocation of a function at a time. Este nivel de simultaneidad podría no ser suficiente en una o varias de las siguientes situaciones:This concurrency level might not be sufficient under one or more of the following conditions:

  • Está intentando administrar un gran número de invocaciones a la vez.You're trying to handle a number of invocations being made at the same time.
  • Está procesando un gran número de eventos de E/S.You're processing a large number of I/O events.
  • La aplicación está enlazada a E/S.Your application is I/O bound.

En estas situaciones, puede mejorar el rendimiento mediante una ejecución asincrónica y el uso de varios procesos de trabajo de lenguaje.In these situations, you can improve performance by running asynchronously and by using multiple language worker processes.

AsyncAsync

Le recomendamos que utilice las instrucciones async defpara que su función se ejecute como corrutina asincrónica.We recommend that you use the async def statement to make your function run as an asynchronous coroutine.

# Runs with asyncio directly

async def main():
    await some_nonblocking_socket_io_op()

Si la función main() es sincrónica (no tiene el calificador async), se ejecuta automáticamente en un grupo de subprocesos asyncio.When the main() function is synchronous (without the async qualifier), the function is automatically run in an asyncio thread-pool.

# Runs in an asyncio thread-pool

def main():
    some_blocking_socket_io()

Uso de procesos de trabajo de varios lenguajesUse multiple language worker processes

De forma predeterminada, cada instancia de host de Functions tiene un único proceso de trabajo de lenguaje.By default, every Functions host instance has a single language worker process. Sin embargo, hay compatibilidad para tener varios procesos de trabajo de lenguaje por cada instancia de host.However there's support to have multiple language worker processes per host instance. Las invocaciones de función se pueden distribuir uniformemente entre estos procesos de trabajo de lenguaje.Function invocations can then be evenly distributed among these language worker processes. Use la configuración de la aplicación FUNCTIONS_WORKER_PROCESS_COUNT para cambiar este valor.Use the FUNCTIONS_WORKER_PROCESS_COUNT application setting to change this value.

ContextContext

Para obtener el contexto de invocación de una función durante la ejecución, incluya el argumento context en su firma.To get the invocation context of a function during execution, include the context argument in its signature.

Por ejemplo:For example:

import azure.functions


def main(req: azure.functions.HttpRequest,
         context: azure.functions.Context) -> str:
    return f'{context.invocation_id}'

La clase Context tiene los atributos de cadena siguientes:The Context class has the following string attributes:

function_directory
El directorio en que se ejecuta la función.The directory in which the function is running.

function_name
El nombre de la función.Name of the function.

invocation_id
El identificador de la invocación de la función actual.ID of the current function invocation.

Variables globalesGlobal variables

No se garantiza la conservación del estado de la aplicación para las ejecuciones futuras.It is not guaranteed that the state of your app will be preserved for future executions. Sin embargo, Azure Functions Runtime suele reutilizar el mismo proceso para varias ejecuciones de la misma aplicación.However, the Azure Functions runtime often reuses the same process for multiple executions of the same app. Para almacenar en caché los resultados de un cálculo costoso, debe declararse como variable global.In order to cache the results of an expensive computation, declare it as a global variable.

CACHED_DATA = None


def main(req):
    global CACHED_DATA
    if CACHED_DATA is None:
        CACHED_DATA = load_json()

    # ... use CACHED_DATA in code

Variables de entornoEnvironment variables

En Functions, la configuración de la aplicación, como las cadenas de conexión del servicio, se exponen como variables de entorno durante la ejecución.In Functions, application settings, such as service connection strings, are exposed as environment variables during execution. Puede acceder a esta configuración mediante la declaración de import os y el uso de setting = os.environ["setting-name"].You can access these settings by declaring import os and then using, setting = os.environ["setting-name"].

En el siguiente ejemplo se obtiene la configuración de la aplicación, con la clave denominada myAppSetting:The following example gets the application setting, with the key named myAppSetting:

import logging
import os
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:

    # Get the setting named 'myAppSetting'
    my_app_setting_value = os.environ["myAppSetting"]
    logging.info(f'My app setting value:{my_app_setting_value}')

Para el desarrollo local, la configuración de la aplicación se mantiene en el archivo local.settings.json.For local development, application settings are maintained in the local.settings.json file.

Versión de PythonPython version

Actualmente, Azure Functions admite Python 3.6.x y 3.7.x (distribuciones oficiales de CPython).Currently, Azure Functions supports both Python 3.6.x and 3.7.x (official CPython distributions). Cuando se ejecuta localmente, el entorno de ejecución usa la versión de Python disponible.When running locally, the runtime uses the available Python version. Para solicitar una versión específica de Python al crear la aplicación de funciones en Azure, use la opción --runtime-version del comando az functionapp create.To request a specific Python version when you create your function app in Azure, use the --runtime-version option of the az functionapp create command.

Administración de paquetesPackage management

Al desarrollar localmente con Azure Functions Core Tools o Visual Studio Code, agregue los nombres y las versiones de los paquetes necesarios al archivo requirements.txt e instálelos mediante pip.When developing locally using the Azure Functions Core Tools or Visual Studio Code, add the names and versions of the required packages to the requirements.txt file and install them using pip.

Por ejemplo, se puede usar el comando de archivo y pip siguiente para instalar el paquete requests desde PyPI.For example, the following requirements file and pip command can be used to install the requests package from PyPI.

requests==2.19.1
pip install -r requirements.txt

Publicación en AzurePublishing to Azure

Cuando esté preparado para la publicación, asegúrese de que todas las dependencias disponibles públicamente están incluidas en el archivo requirements.txt, que se encuentra en la raíz del directorio del proyecto.When you're ready to publish, make sure that all your publicly available dependencies are listed in the requirements.txt file, which is located at the root of your project directory.

Los archivos de proyecto y las carpetas que se excluyen de la publicación, incluida la carpeta del entorno virtual, se enumeran en el archivo. funcignore.Project files and folders that are excluded from publishing, including the virtual environment folder, are listed in the .funcignore file.

Se admiten tres acciones de compilación para publicar el proyecto de Python en Azure:There are three build actions supported for publishing your Python project to Azure:

  • Compilación remota: las dependencias se obtienen de forma remota en función del contenido del archivo requirements.txt.Remote build: Dependencies are obtained remotely based on the contents of the requirements.txt file. La compilación remota es el método de compilación recomendado.Remote build is the recommended build method. Esta es también la opción de compilación predeterminada de las herramientas de Azure.Remote is also the default build option of Azure tooling.
  • Compilación local: las dependencias se obtienen de forma local en función del contenido del archivo requirements.txt.Local build: Dependencies are obtained locally based on the contents of the requirements.txt file.
  • Dependencias personalizadas: el proyecto usa paquetes que no están disponibles públicamente para nuestras herramientas.Custom dependencies: Your project uses packages not publicly available to our tools. Esta opción requiere Docker.(Requires Docker.)

Para crear sus dependencias y publicarlas mediante un sistema de entrega continua (CD), use Azure Pipelines.To build your dependencies and publish using a continuous delivery (CD) system, use Azure Pipelines.

Compilación remotaRemote build

De forma predeterminada, Azure Functions Core Tools solicita una compilación remota cuando se usa el siguiente comando func azure functionapp publish para publicar el proyecto de Python en Azure.By default, the Azure Functions Core Tools requests a remote build when you use the following func azure functionapp publish command to publish your Python project to Azure.

func azure functionapp publish <APP_NAME>

Reemplace <APP_NAME> por el nombre de la aplicación de función de Azure.Remember to replace <APP_NAME> with the name of your function app in Azure.

La extensión de Azure Functions para Visual Studio Code también solicita de forma predeterminada una compilación remota.The Azure Functions Extension for Visual Studio Code also requests a remote build by default.

Compilación localLocal build

Puede impedir que se lleve a cabo una compilación remota usando el siguiente comando func azure functionapp publish para publicar con una compilación local.You can prevent doing a remote build by using the following func azure functionapp publish command to publish with a local build.

func azure functionapp publish <APP_NAME> --build local

Reemplace <APP_NAME> por el nombre de la aplicación de función de Azure.Remember to replace <APP_NAME> with the name of your function app in Azure.

Con la opción --build local, las dependencias del proyecto se leen del archivo requirements.txt y los paquetes dependientes se descargan e instalan localmente.Using the --build local option, project dependencies are read from the requirements.txt file and those dependent packages are downloaded and installed locally. Los archivos de proyecto y las dependencias se implementan desde el equipo local en Azure.Project files and dependencies are deployed from your local computer to Azure. Esto hace que se cargue un paquete de implementación más grande en Azure.This results in a larger deployment package being uploaded to Azure. Si, por alguna razón, Core Tools no puede obtener las dependencias del archivo requirements.txt, debe usar la opción de dependencias personalizadas para la publicación.If for some reason, dependencies in your requirements.txt file can't be acquired by Core Tools, you must use the custom dependencies option for publishing.

Dependencias personalizadasCustom dependencies

Si el proyecto usa paquetes que no están disponibles públicamente para nuestras herramientas, puede ponerlos a disposición de la aplicación colocándolos en el directorio __app__/.python_packages.If your project uses packages not publicly available to our tools, you can make them available to your app by putting them in the __app__/.python_packages directory. Antes de la publicación, ejecute el siguiente comando para instalar las dependencias localmente:Before publishing, run the following command to install the dependencies locally:

pip install  --target="<PROJECT_DIR>/.python_packages/lib/site-packages"  -r requirements.txt

Al usar dependencias personalizadas, debe usar la opción de publicación --no-build, puesto que ya ha instalado las dependencias.When using custom dependencies, you should use the --no-build publishing option, since you have already installed the dependencies.

func azure functionapp publish <APP_NAME> --no-build

Reemplace <APP_NAME> por el nombre de la aplicación de función de Azure.Remember to replace <APP_NAME> with the name of your function app in Azure.

Pruebas unitariasUnit Testing

Las funciones escritas en Python se pueden probar como otro código de Python mediante marcos de pruebas.Functions written in Python can be tested like other Python code using standard testing frameworks. Para la mayoría de los enlaces, es posible crear un objeto de entrada ficticio creando una instancia de una clase adecuada a partir del paquete azure.functions.For most bindings, it's possible to create a mock input object by creating an instance of an appropriate class from the azure.functions package. Dado que el paquete azure.functions no está disponible inmediatamente, asegúrese de instalarlo a través del archivo requirements.txt, tal como se describe en la sección Administración de paquetes anterior.Since the azure.functions package is not immediately available, be sure to install it via your requirements.txt file as described in the package management section above.

Por ejemplo, a continuación se muestra una prueba ficticia de una función desencadenada por HTTP:For example, following is a mock test of an HTTP triggered function:

{
  "scriptFile": "__init__.py",
  "entryPoint": "my_function",
  "bindings": [
    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    }
  ]
}
# __app__/HttpTrigger/__init__.py
import azure.functions as func
import logging

def my_function(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    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(f"Hello {name}")
    else:
        return func.HttpResponse(
             "Please pass a name on the query string or in the request body",
             status_code=400
        )
# tests/test_httptrigger.py
import unittest

import azure.functions as func
from __app__.HttpTrigger import my_function

class TestFunction(unittest.TestCase):
    def test_my_function(self):
        # Construct a mock HTTP request.
        req = func.HttpRequest(
            method='GET',
            body=None,
            url='/api/HttpTrigger',
            params={'name': 'Test'})

        # Call the function.
        resp = my_function(req)

        # Check the output.
        self.assertEqual(
            resp.get_body(),
            b'Hello Test',
        )

Este es otro ejemplo, con una función desencadenada por la cola:Here is another example, with a queue triggered function:

{
  "scriptFile": "__init__.py",
  "entryPoint": "my_function",
  "bindings": [
    {
      "name": "msg",
      "type": "queueTrigger",
      "direction": "in",
      "queueName": "python-queue-items",
      "connection": "AzureWebJobsStorage"
    }
  ]
}
# __app__/QueueTrigger/__init__.py
import azure.functions as func

def my_function(msg: func.QueueMessage) -> str:
    return f'msg body: {msg.get_body().decode()}'
# tests/test_queuetrigger.py
import unittest

import azure.functions as func
from __app__.QueueTrigger import my_function

class TestFunction(unittest.TestCase):
    def test_my_function(self):
        # Construct a mock Queue message.
        req = func.QueueMessage(
            body=b'test')

        # Call the function.
        resp = my_function(req)

        # Check the output.
        self.assertEqual(
            resp,
            'msg body: test',
        )

Archivos temporalesTemporary files

El método tempfile.gettempdir() devuelve una carpeta temporal, que en Linux es /tmp.The tempfile.gettempdir() method returns a temporary folder, which on Linux is /tmp. La aplicación puede usar este directorio para almacenar los archivos temporales generados y usados por las funciones durante la ejecución.Your application can use this directory to store temporary files generated and used by your functions during execution.

Importante

No se garantiza que los archivos escritos en el directorio temporal persistan entre invocaciones.Files written to the temporary directory aren't guaranteed to persist across invocations. Durante el escalado horizontal, los archivos temporales no se comparten entre instancias.During scale out, temporary files aren't shared between instances.

En el ejemplo siguiente se crea un archivo temporal con nombre en el directorio temporal (/tmp):The following example creates a named temporary file in the temporary directory (/tmp):

import logging
import azure.functions as func
import tempfile
from os import listdir

#---
   tempFilePath = tempfile.gettempdir()   
   fp = tempfile.NamedTemporaryFile()     
   fp.write(b'Hello world!')              
   filesDirListInTemp = listdir(tempFilePath)     

Se recomienda mantener las pruebas en una carpeta independiente de la carpeta del proyecto.We recommend that you maintain your tests in a folder separate from the project folder. Esto evita que se implemente código de prueba con la aplicación.This keeps you from deploying test code with your app.

Problemas conocidos y preguntas más frecuentesKnown issues and FAQ

Todos los problemas conocidos y las solicitudes de características se siguen mediante la lista deproblemas de GitHub.All known issues and feature requests are tracked using GitHub issues list. Si le surge algún problema y no lo encuentra en GitHub, abra un nuevo problema e incluya una descripción detallada del mismo.If you run into a problem and can't find the issue in GitHub, open a new issue and include a detailed description of the problem.

Uso compartido de recursos entre orígenesCross-origin resource sharing

Azure Functions admite el uso compartido de recursos entre orígenes (CORS).Azure Functions supports cross-origin resource sharing (CORS). CORS se configura en el portal y mediante la CLI de Azure.CORS is configured in the portal and through the Azure CLI. La lista de orígenes permitidos de CORS se aplica en el nivel de la aplicación de función.The CORS allowed origins list applies at the function app level. Con CORS habilitado, las respuestas incluyen el encabezado Access-Control-Allow-Origin.With CORS enabled, responses include the Access-Control-Allow-Origin header. Para obtener más información, consulte Uso compartido de recursos entre orígenes.For more information, see Cross-origin resource sharing.

La lista de orígenes permitidos no se admite actualmente para las aplicaciones de función de Python.The allowed origins list isn't currently supported for Python function apps. Debido a esta limitación, debe establecer expresamente el encabezado Access-Control-Allow-Origin en las funciones HTTP, tal y como se muestra en el ejemplo siguiente:Because of this limitation, you must expressly set the Access-Control-Allow-Origin header in your HTTP functions, as shown in the following example:

def main(req: func.HttpRequest) -> func.HttpResponse:

    # Define the allow origin headers.
    headers = {"Access-Control-Allow-Origin": "https://contoso.com"}

    # Set the headers in the response.
    return func.HttpResponse(
            f"Allowed origin '{headers}'.",
            headers=headers, status_code=200
    )

Asegúrese de actualizar también el archivo function.json para admitir el método HTTP OPTIONS:Make sure that you also update your function.json to support the OPTIONS HTTP method:

    ...
      "methods": [
        "get",
        "post",
        "options"
      ]
    ...

El explorador Chrome usa este método para negociar la lista de orígenes permitidos.This method is used by the Chrome browser to negotiate the allowed origins list.

Pasos siguientesNext steps

Para obtener más información, consulte los siguientes recursos:For more information, see the following resources: