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.

Como desarrollador de Python, puede que también le interese uno de los siguientes artículos:As a Python developer, you may also be interested in one of the following articles:

IntroducciónGetting started ConceptosConcepts Escenarios y ejemplosScenarios/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:

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

Según esta definición, el archivo __init__.py que contiene el código de la función puede ser similar al siguiente ejemplo:Based on this definition, the __init__.py file that contains the function code might look like the following example:

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

También puede declarar de forma explícita 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:

 <project_root>/
 | - .venv/
 | - .vscode/
 | - my_first_function/
 | | - __init__.py
 | | - function.json
 | | - example.py
 | - my_second_function/
 | | - __init__.py
 | | - function.json
 | - shared_code/
 | | - __init__.py
 | | - my_first_helper_function.py
 | | - my_second_helper_function.py
 | - tests/
 | | - test_my_second_function.py
 | - .funcignore
 | - host.json
 | - local.settings.json
 | - requirements.txt
 | - Dockerfile

La carpeta de proyecto principal (<project_root>) puede contener los siguientes archivos:The main project folder (<project_root>) 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 de Python que se instalan al publicar en Azure.requirements.txt: Contains the list of Python 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.
  • .vscode/ : (Opcional) Contiene la configuración de VSCode de almacenamiento..vscode/: (Optional) Contains store VSCode configuration. Para más información, consulte Configuración de VSCode.To learn more, see VSCode setting.
  • .venv/ : (Opcional) Contiene un entorno virtual de Python usado para el desarrollo local..venv/: (Optional) Contains a Python virtual environment used by local development.
  • Dockerfile: (Opcional) se usa al publicar el proyecto en un contenedor personalizado.Dockerfile: (Optional) Used when publishing your project in a custom container.
  • tests/ : (Opcional) Contiene los casos de prueba de la aplicación de funciones.tests/: (Optional) Contains the test cases of your function app.
  • .funcignore: (Opcional) declara los archivos que no deben publicarse en Azure..funcignore: (Optional) Declares files that shouldn't get published to Azure. Normalmente, este archivo contiene .vscode/ para omitir la configuración del editor, .venv/ para omitir el entorno virtual de Python local, tests/ para omitir los casos de prueba y local.settings.json para evitar la publicación de la configuración de la aplicación local.Usually, this file contains .vscode/ to ignore your editor setting, .venv/ to ignore local Python virtual environment, tests/ to ignore test cases, and local.settings.json to prevent local app settings being published.

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

Al implementar el proyecto en una aplicación de funciones de Azure, debe incluirse en el paquete todo el contenido de la carpeta principal del proyecto ( <project_root> ), pero no la propia carpeta, lo que significa que host.json debe estar en la raíz del paquete.When deploying your project to a function app in Azure, the entire contents of the main project (<project_root>) folder should be included in the package, but not the folder itself, which means host.json should be in the package root. Se recomienda mantener las pruebas en una carpeta junto con otras funciones; en este ejemplo, tests/.We recommend that you maintain your tests in a folder along with other functions, in this example tests/. Para más información, consulte Pruebas unitarias.For more information, see Unit Testing.

Comportamiento de la importaciónImport behavior

Puede importar módulos en el código de la función mediante referencias absolutas y relativas.You can import modules in your function code using both absolute and relative references. En el caso de la estructura de carpetas que se mostró anteriormente, las siguientes operaciones de importación trabajan desde el archivo de función <project_root>\my_first_function\__init__.py:Based on the folder structure shown above, the following imports work from within the function file <project_root>\my_first_function\__init__.py:

from shared_code import my_first_helper_function #(absolute)
import shared_code.my_second_helper_function #(absolute)
from . import example #(relative)

Nota

La carpeta shared_code/ debe contener el archivo __init__.py para marcarlo como un paquete de Python al usar la sintaxis de la importación absoluta.The shared_code/ folder needs to contain an __init__.py file to mark it as a Python package when using absolute import syntax.

La siguiente importación de __aplicación__ y las importaciones relativas de nivel superior están en desuso, ya que no son compatibles con el comprobador de tipos estático y no son compatibles con los marcos de pruebas de Python:The following __app__ import and beyond top-level relative import are deprecated, since it is not supported by static type checker and not supported by Python test frameworks:

from __app__.shared_code import my_first_helper_function #(deprecated __app__ import)
from ..shared_code import my_first_helper_function #(deprecated beyond top-level relative import)

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 en la configuración de la aplicación AzureWebJobsStorage, 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 the AzureWebJobsStorage app setting, 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.json 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.

Escalado y rendimientoScaling and Performance

Es importante comprender el rendimiento de las funciones y cómo afecta a la manera en que se escala la aplicación de funciones.It's important to understand how your functions perform and how that performance affects the way your function app gets scaled. Esto es especialmente importante al diseñar aplicaciones de alto rendimiento.This is particularly important when designing highly performant apps. A continuación se indican algunos factores que se deben tener en cuenta al diseñar, escribir y configurar las aplicaciones de funciones.The following are several factors to consider when designing, writing and configuring your functions apps.

Escalado horizontalHorizontal scaling

De forma predeterminada, Azure Functions supervisa automáticamente la carga en la aplicación y crea instancias de host adicionales para Python según sea necesario.By default, Azure Functions automatically monitors the load on your application and creates additional host instances for Python as needed. Functions usa umbrales integrados en diferentes tipos de desencadenadores para decidir cuándo se deben agregar instancias, como la antigüedad de los mensajes y el tamaño de la cola para QueueTrigger.Functions uses built-in thresholds for different trigger types to decide when to add instances, such as the age of messages and queue size for QueueTrigger. Estos umbrales no puede configurarlos el usuario.These thresholds aren't user configurable. Para obtener más información, consulte Cómo funcionan los planes de consumo y Premium.For more information, see How the Consumption and Premium plans work.

Mejora del rendimientoImproving throughput performance

Una clave para mejorar el rendimiento es comprender cómo usa la aplicación los recursos y poder configurar la aplicación de funciones en consecuencia.A key to improving performance is understanding how your app uses resources and being able to configure your function app accordingly.

Descripción de la carga de trabajoUnderstanding your workload

Las configuraciones predeterminadas son adecuadas para la mayoría de las aplicaciones de Azure Functions.The default configurations are suitable for most of Azure Functions applications. Sin embargo, puede mejorar el rendimiento de las aplicaciones mediante configuraciones basadas en el perfil de la carga de trabajo.However, you can improve the performance of your applications' throughput by employing configurations based on your workload profile. El primer paso es comprender el tipo de carga de trabajo que se está ejecutando.The first step is to understand the type of workload that you are running.

Carga de trabajo dependiente de E/SI/O-bound workload Carga de trabajo dependiente de CPUCPU-bound workload
Características de la aplicación de funcionesFunction app characteristics
  • La aplicación necesita controlar muchas invocaciones simultáneas.App needs to handle many concurrent invocations.
  • La aplicación procesa un gran número de eventos de E/S, como llamadas de red y lecturas o escrituras de disco.App processes a large number of I/O events, such as network calls and disk read/writes.
  • La aplicación realiza cálculos de ejecución prolongada, como el cambio de tamaño de las imágenes.App does long-running computations, such as image resizing.
  • La aplicación realiza la transformación de datos.App does data transformation.
EjemplosExamples
  • API webWeb APIs
    • Procesamiento de datosData processing
    • Inferencia de Machine LearningMachine learning inference

      Nota

      Dado que la carga de trabajo de las funciones reales casi siempre es una combinación dependiente de E/S y CPU, se recomienda generar un perfil de la carga de trabajo con cargas de producción realistas.As real world functions workload are most of often a mix of I/O and CPU bound, we recommend to profile the workload under realistic production loads.

      Configuraciones específicas del rendimientoPerformance-specific configurations

      Después de entender el perfil de la carga de trabajo de la aplicación de funciones, puede usar las configuraciones que se muestran a continuación para mejorar el rendimiento de las funciones.After understanding the workload profile of your function app, the following are configurations that you can use to improve the throughput performance of your functions.

      AsyncAsync

      Dado que Python es un entorno de ejecución de un solo subproceso, una instancia de host para Python solo puede procesar una invocación de función cada vez.Because Python is a single-threaded runtime, a host instance for Python can process only one function invocation at a time. En el caso de las aplicaciones que procesan un gran número de eventos de E/S o que son dependientes de las operaciones de E/S, puede mejorar considerablemente el rendimiento mediante la ejecución de funciones de forma asincrónica.For applications that process a large number of I/O events and/or is I/O bound, you can improve performance significantly by running functions asynchronously.

      Para ejecutar una función de forma asincrónica, use la instrucción async def, que ejecuta la función directamente con asyncio:To run a function asynchronously, use the async def statement, which runs the function with asyncio directly:

      async def main():
          await some_nonblocking_socket_io_op()
      

      Este es un ejemplo de una función con un desencadenador HTTP que usa el cliente http aiohttp:Here is an example of a function with HTTP trigger that uses aiohttp http client:

      import aiohttp
      
      import azure.functions as func
      
      async def main(req: func.HttpRequest) -> func.HttpResponse:
          async with aiohttp.ClientSession() as client:
              async with client.get("PUT_YOUR_URL_HERE") as response:
                  return func.HttpResponse(await response.text())
      
          return func.HttpResponse(body='NotFound', status_code=404)
      

      Una función sin la palabra clave async se ejecuta de forma automática en un grupo de subprocesos de asyncio:A function without the async keyword is run automatically in an asyncio thread-pool:

      # Runs in an asyncio thread-pool
      
      def main():
          some_blocking_socket_io()
      

      Para sacar el máximo beneficio de ejecutar funciones de forma asincrónica, la operación de E/S o la biblioteca que se usa en el código también debe tener implementado el patrón asincrónico.In order to achieve the full benefit of running functions asynchronously, the I/O operation/library that is used in your code needs to have async implemented as well. El uso de operaciones de E/S sincrónicas en funciones que se definen como asincrónicas puede perjudicar al rendimiento general.Using synchronous I/O operations in functions that are defined as asynchronous may hurt the overall performance.

      Estos son algunos ejemplos de bibliotecas cliente que han implementado el patrón asincrónico:Here are a few examples of client libraries that has implemented async pattern:

      • aiohttp: cliente/servidor http para asyncio.aiohttp - Http client/server for asyncio
      • Streams API: primitivas preparadas para async/await de alto nivel para trabajar con la conexión de red.Streams API - High-level async/await-ready primitives to work with network connection
      • Janus Queue: cola con reconocimiento de asyncio segura para subprocesos para PythonJanus Queue - Thread-safe asyncio-aware queue for Python
      • pyzmq: enlaces de Python para ZeroMQ.pyzmq - Python bindings for ZeroMQ
      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. Puede aumentar el número de procesos de trabajo por host (hasta 10) mediante la configuración de la aplicación FUNCTIONS_WORKER_PROCESS_COUNT.You can increase the number of worker processes per host (up to 10) by using the FUNCTIONS_WORKER_PROCESS_COUNT application setting. Al hacerlo, Azure Functions intenta distribuir uniformemente las invocaciones de función simultáneas en estos trabajos.Azure Functions then tries to evenly distribute simultaneous function invocations across these workers.

      En el caso de las aplicaciones dependientes de CPU, debe establecer el número de trabajos de lenguaje para que sea igual o mayor que el número de núcleos disponibles por aplicación de funciones.For CPU bound apps, you should set the number of language worker to be the same as or higher than the number of cores that are available per function app. Para obtener más información, consulte las SKU de instancias disponibles.To learn more, see Available instance SKUs.

      Las aplicaciones dependientes de E/S también pueden beneficiarse del aumento del número de procesos de trabajo más allá del número de núcleos disponibles.I/O-bound apps may also benefit from increasing the number of worker processes beyond the number of cores available. Tenga en cuenta que establecer un número de roles de trabajo demasiado alto puede afectar al rendimiento general debido al mayor número de cambios de contexto necesarios.Keep in mind that setting the number of workers too high can impact overall performance due to the increased number of required context switches.

      FUNCTIONS_WORKER_PROCESS_COUNT se aplica a cada host que Functions crea al escalar horizontalmente la aplicación para satisfacer la demanda.The FUNCTIONS_WORKER_PROCESS_COUNT applies to each host that Functions creates when scaling out your application to meet demand.

      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.function_directory The directory in which the function is running.

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

      invocation_id El identificador de la invocación de la función actual.invocation_id 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

      Azure Functions admite las siguientes versiones de Python:Azure Functions supports the following Python versions:

      Versión de FunctionsFunctions version Versiones de Python*Python* versions
      3.x3.x 3.83.8
      3.73.7
      3.63.6
      2.x2.x 3.73.7
      3.63.6

      *Distribuciones oficiales de CPython*Official CPython distributions

      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. La versión de tiempo de ejecución de Functions se establece mediante la opción --functions-version.The Functions runtime version is set by the --functions-version option. La versión de Python se establece al crear la aplicación de funciones y no se puede cambiar.The Python version is set when the function app is created and can't be changed.

      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.

      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: compilación remota, compilación local y compilaciones mediante dependencias personalizadas.There are three build actions supported for publishing your Python project to Azure: remote build, local build, and builds using custom dependencies.

      También puede usar Azure Pipelines para compilar las dependencias y publicarlas mediante la entrega continua (CD).You can also use Azure Pipelines to build your dependencies and publish using continuous delivery (CD). Para más información, vea Entrega continua con Azure DevOps.To learn more, see Continuous delivery by using Azure DevOps.

      Compilación remotaRemote build

      Cuando se usa la compilación remota, las dependencias restauradas en el servidor y las dependencias nativas coinciden con el entorno de producción.When using remote build, dependencies restored on the server and native dependencies match the production environment. Esto da como resultado un paquete de implementación más pequeño para cargar.This results in a smaller deployment package to upload. Use la compilación remota para desarrollar aplicaciones de Python en Windows.Use remote build when developing Python apps on Windows. Si el proyecto tiene dependencias personalizadas, puede usar la compilación remota con la dirección URL de índice adicional.If your project has custom dependencies, you can use remote build with extra index URL.

      las dependencias se obtienen de forma remota en función del contenido del archivo requirements.txt.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. 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

      las dependencias se obtienen de forma local en función del contenido del archivo requirements.txt.Dependencies are obtained locally based on the contents of the requirements.txt file. 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.

      No se recomienda usar compilaciones locales al desarrollar localmente en Windows.We don't recommend using local builds when developing locally on Windows.

      Dependencias personalizadasCustom dependencies

      Cuando el proyecto tiene dependencias que no se encuentran en el índice de paquetes de Python, hay dos maneras de compilar el proyecto.When your project has dependencies not found in the Python Package Index, there are two ways to build the project. El método de compilación depende de cómo se compile el proyecto.The build method depends on how you build the project.

      Compilación remota con dirección URL de índice adicionalRemote build with extra index URL

      Cuando los paquetes estén disponibles desde un índice de paquetes personalizado accesible, use una compilación remota.When your packages are available from an accessible custom package index, use a remote build. Antes de publicar, asegúrese de crear una configuración de aplicación denominada PIP_EXTRA_INDEX_URL.Before publishing, make sure to create an app setting named PIP_EXTRA_INDEX_URL. El valor de esta configuración es la dirección URL del índice de paquetes personalizado.The value for this setting is the URL of your custom package index. El uso de esta configuración indica a la compilación remota que ejecute pip install mediante la opción --extra-index-url.Using this setting tells the remote build to run pip install using the --extra-index-url option. Para más información, vea la documentación de instalación de pip de Python.To learn more, see the Python pip install documentation.

      También puede utilizar las credenciales de autenticación básica con las direcciones URL del índice de paquetes adicional.You can also use basic authentication credentials with your extra package index URLs. Para más información, vea Credenciales de autenticación básica en la documentación de Python.To learn more, see Basic authentication credentials in Python documentation.

      Instalación de paquetes localesInstall local packages

      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 en la carpeta del proyecto.When using custom dependencies, you should use the --no-build publishing option, since you have already installed the dependencies into the project folder.

      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.

      Si tomamos my_second_function como ejemplo, a continuación se muestra una prueba ficticia de una función desencadenada por HTTP:Take my_second_function as an example, following is a mock test of an HTTP triggered function:

      En primer lugar, debemos crear el archivo <project_root>/my_second_function/function.json y definir esta función como un desencadenador HTTP.First we need to create <project_root>/my_second_function/function.json file and define this function as an http trigger.

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

      Ahora, podemos implementar my_second_function y shared_code.my_second_helper_function.Now, we can implement the my_second_function and the shared_code.my_second_helper_function.

      # <project_root>/my_second_function/__init__.py
      import azure.functions as func
      import logging
      
      # Use absolute import to resolve shared_code modules
      from shared_code import my_second_helper_function
      
      # Define an http trigger which accepts ?value=<int> query parameter
      # Double the value and return the result in HttpResponse
      def main(req: func.HttpRequest) -> func.HttpResponse:
          logging.info('Executing my_second_function.')
      
          initial_value: int = int(req.params.get('value'))
          doubled_value: int = my_second_helper_function.double(initial_value)
      
          return func.HttpResponse(
            body=f"{initial_value} * 2 = {doubled_value}",
            status_code=200
          )
      
      # <project_root>/shared_code/__init__.py
      # Empty __init__.py file marks shared_code folder as a Python package
      
      # <project_root>/shared_code/my_second_helper_function.py
      
      def double(value: int) -> int:
        return value * 2
      

      Podemos empezar a escribir casos de prueba para nuestro desencadenador HTTP.We can start writing test cases for our http trigger.

      # <project_root>/tests/test_my_second_function.py
      import unittest
      
      import azure.functions as func
      from my_second_function import main
      
      class TestFunction(unittest.TestCase):
          def test_my_second_function(self):
              # Construct a mock HTTP request.
              req = func.HttpRequest(
                  method='GET',
                  body=None,
                  url='/api/my_second_function',
                  params={'value': '21'})
      
              # Call the function.
              resp = main(req)
      
              # Check the output.
              self.assertEqual(
                  resp.get_body(),
                  b'21 * 2 = 42',
              )
      

      Dentro del entorno virtual de Python, .venv, instale el marco de pruebas de Python que prefiera (por ejemplo, pip install pytest).Inside your .venv Python virtual environment, install your favorite Python test framework (e.g. pip install pytest). Simplemente ejecute pytest tests para comprobar el resultado de la prueba.Simply run pytest tests to check the test result.

      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.

      Bibliotecas preinstaladasPreinstalled libraries

      Hay algunas bibliotecas que se incluyen en Functions Runtime para Python.There are a few libraries come with the Python Functions runtime.

      Biblioteca estándar de PythonPython Standard Library

      La biblioteca estándar de Python contiene una lista de módulos de Python integrados que se incluyen con cada distribución de Python.The Python Standard Library contain a list of built-in Python modules that are shipped with each Python distribution. La mayoría de estas bibliotecas lo ayudan a acceder a la funcionalidad del sistema, como la E/S de archivos.Most of these libraries help you access system functionality, like file I/O. En los sistemas Windows, estas bibliotecas se instalan con Python.On Windows systems, these libraries are installed with Python. En los sistemas basados en Unix, las proporcionan las colecciones de paquetes.On the Unix-based systems, they are provided by package collections.

      Para ver todos los detalles de la lista de estas bibliotecas, visite los vínculos siguientes:To view the full details of the list of these libraries, please visit the links below:

      Dependencias de trabajo de Python en Azure FunctionsAzure Functions Python worker dependencies

      El trabajo de Python en Functions requiere un conjunto específico de bibliotecas.The Functions Python worker requires a specific set of libraries. También puede usar estas bibliotecas en sus funciones, pero no forman parte del estándar de Python.You can also use these libraries in your functions, but they aren't a part of the Python standard. Si las funciones se basan en cualquiera de estas bibliotecas, puede que no estén disponibles para el código cuando se ejecutan fuera de Azure Functions.If your functions rely on any of these libraries, they may not be available to your code when running outside of Azure Functions. Puede encontrar una lista detallada de las dependencias en la sección install_requires del archivo setup.py.You can find a detailed list of dependencies in the install_requires section in the setup.py file.

      Nota

      Si el archivo requirements.txt de la aplicación de funciones contiene una entrada azure-functions-worker, quítela.If your function app's requirements.txt contains an azure-functions-worker entry, remove it. El trabajo de funciones se administra automáticamente mediante la plataforma de Azure Functions y se actualiza periódicamente con nuevas características y correcciones de errores.The functions worker is automatically managed by Azure Functions platform, and we regularly update it with new features and bug fixes. La instalación manual de una versión anterior del trabajo en el archivo requirements.txt puede producir problemas inesperados.Manually installing an old version of worker in requirements.txt may cause unexpected issues.

      Biblioteca de Python para Azure FunctionsAzure Functions Python library

      Cada actualización de trabajado de Python incluye una nueva versión de la biblioteca de Python para Azure Functions (azure.functions).Every Python worker update includes a new version of Azure Functions Python library (azure.functions). Este enfoque facilita la actualización continua de las aplicaciones de funciones de Python, ya que cada actualización es compatible con versiones anteriores.This approach makes it easier to continuously update your Python function apps, because each update is backwards-compatible. Puede encontrar una lista de las versiones de esta biblioteca en azure-functions en PyPi.A list of releases of this library can be found in azure-functions PyPi.

      La versión de la biblioteca en tiempo de ejecución la determina Azure y no se puede reemplazar por requirements.txt.The runtime library version is fixed by Azure, and it can't be overridden by requirements.txt. La entrada azure-functions en requirements.txt es solo para linting y reconocimiento de clientes.The azure-functions entry in requirements.txt is only for linting and customer awareness.

      Use el código siguiente para realizar un seguimiento de la versión real de la biblioteca de Python para Functions en tiempo de ejecución:Use the following code to track the actual version of the Python Functions library in your runtime:

      getattr(azure.functions, '__version__', '< 1.2.1')
      

      Bibliotecas de sistema en tiempo de ejecuciónRuntime system libraries

      Para obtener una lista de las bibliotecas de sistema preinstaladas en las imágenes de Docker de trabajo de Python, siga estos vínculos:For a list of preinstalled system libraries in Python worker Docker images, please follow the links below:

      Sistema en tiempo de ejecución de FunctionsFunctions runtime Versión de DebianDebian version Versiones de PythonPython versions
      Versión 2.xVersion 2.x StretchStretch Python 3.6Python 3.6
      Python 3.7Python 3.7
      Versión 3.xVersion 3.x BusterBuster Python 3.6Python 3.6
      Python 3.7Python 3.7
      Python 3.8Python 3.8

      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.

      CORS es totalmente compatible con las aplicaciones de funciones de Python.CORS is fully supported for Python function apps.

      Problemas conocidos y preguntas más frecuentesKnown issues and FAQ

      A continuación, se muestra una lista de las guías de solución de problemas comunes:Following is a list of troubleshooting guides for common issues:

      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.

      Pasos siguientesNext steps

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

      ¿Tiene problemas? Háganoslo saber.Having issues? Let us know.