Compartir a través de

Guía de referencia del desarrollador de Azure Functions para aplicaciones de Python

Azure Functions es un servicio de proceso sin servidor que permite ejecutar código controlado por eventos sin aprovisionar ni administrar la infraestructura. Las ejecuciones de funciones se desencadenan mediante eventos como solicitudes HTTP, mensajes de cola, temporizadores o cambios en el almacenamiento, y se escalan automáticamente en función de la demanda.

Esta guía se centra específicamente en la creación de Azure Functions basadas en Python y le ayuda a:

  • Creación y ejecución de aplicaciones de funciones localmente
  • Descripción del modelo de programación de Python
  • Organización y configuración de la aplicación
  • Implementación y supervisión de la aplicación en Azure
  • Aplicación de procedimientos recomendados para el escalado y el rendimiento

¿Buscas información general conceptual? Consulte Azure Functions Developer Reference.

¿Te interesan los casos de uso del mundo real? Explore la página Escenarios y ejemplos .

Cómo empezar

Elija el entorno que se adapte al flujo de trabajo y vaya a Azure Functions para Python:

Creación de la aplicación de funciones

En esta sección se tratan los componentes esenciales para crear y estructurar la aplicación de funciones de Python. Entre los temas se incluyen el modelo de programación, la estructura del proyecto, los desencadenadores y los enlaces, y la administración de dependencias.

Modelo de programación

Functions admite dos versiones del modelo de programación de Python:

Versión Descripción
2.x Use un enfoque basado en decorador para definir desencadenadores y enlaces directamente en el archivo de código de Python. Implemente cada función como un método global sin estado en un archivo o un archivo de plantilla al que se hace referencia. Esta versión del modelo se recomienda para las nuevas aplicaciones de Python.
1.x Los desencadenadores y enlaces se definen para cada función en un archivo independiente . Implemente cada función como un método global sin estado en el archivo de código Python. Esta versión del modelo admite aplicaciones heredadas.

Este artículo tiene como destino una versión específica del modelo de Python. Elija la versión deseada en la parte superior del artículo.

Importante

Utilice el modelo de programación v2 para un enfoque basado en decoradores para definir desencadenadores y enlaces directamente en el código.

En el modelo de programación de Python v1, cada función se define como un método de main() global sin estado dentro de un archivo denominado __init__.py. Los disparadores y enlaces de la función se configuran por separado en el archivo , y los valores de los enlaces se utilizan como parámetros en el método .

Ejemplo

Esta es una función sencilla que responde a una solicitud HTTP:

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

Este es el archivo correspondiente :

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

Conceptos clave

  • La función tiene un único desencadenador HTTP.
  • El objeto HttpRequest contiene encabezados de solicitud, parámetros de consulta, parámetros de ruta y el cuerpo del mensaje. Esta función obtiene el valor del parámetro de consulta desde el parámetro del objeto HttpRequest.
  • Para enviar un nombre en este ejemplo, anexe a la dirección URL de la función expuesta. Por ejemplo, si se ejecuta localmente, la dirección URL completa podría ser similar a . Para obtener ejemplos de uso de enlaces, consulte Desencadenadores y enlaces.

Use el SDK e incluya anotaciones de tipo para mejorar la compatibilidad con IntelliSense y el editor:

# __init__.py
import azure.functions as func

def http_trigger(req: func.HttpRequest) -> str:

# requirements.txt
azure-functions

La biblioteca

La biblioteca azure-functions Python proporciona los tipos principales que se usan para interactuar con el entorno de ejecución de Azure Functions. Para ver todos los tipos y métodos disponibles, visite la API. El código de función puede usar para:

  • Acceso a los datos de entrada del desencadenador (por ejemplo, , )
  • Crear valores de salida (como )
  • Interacción con datos de enlace y contexto proporcionados por el entorno de ejecución

Si usas en tu aplicación, debe estar en las dependencias de tu proyecto.

Nota:

La biblioteca azure-functions define la superficie de programación para Python Azure Functions, pero no es un SDK de uso general. Úselo específicamente para crear y ejecutar funciones dentro del entorno de ejecución de Azure Functions.

Punto de entrada alternativo

Puede cambiar el comportamiento predeterminado de una función especificando las propiedades y en el archivo. Por ejemplo, el siguiente archivo dirige el tiempo de ejecución para usar el método en el archivo /> 

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

Estructura de carpetas

Use la siguiente estructura para un proyecto de Python Azure Functions:

<project_root>/
│
├── .venv/                   # (Optional) Local Python virtual environment
├── .vscode/                 # (Optional) VS Code workspace settings
│
├── my_first_function/       # Function directory
│   └── __init__.py          # Function code file
│   └── function.json        # Function binding configuration file
│
├── my_second_function/
│   └── __init__.py  
│   └── function.json 
│
├── shared/                  # (Optional) Pure helper code with no triggers/bindings
│   └── utils.py
│
├── additional_functions/    # (Optional) Contains blueprints for organizing related Functions
│   └── blueprint_1.py  
│
├── tests/                   # (Optional) Unit tests for your functions
│   └── test_my_function.py
│
├── .funcignore              # Excludes files from being published
├── host.json                # Global function app configuration
├── local.settings.json      # Local-only app settings (not published)
├── requirements.txt         # (Optional) Defines Python dependencies for remote build
├── Dockerfile               # (Optional) For custom container deployment

Archivos y carpetas de claves

Archivo/carpeta Descripción Necesario para que la aplicación se ejecute en Azure
my_first_function/ Directorio de una sola función. ✅
__init__.py/ Script principal donde se define la función asociada al código . ✅
function.json/ Contiene la configuración de enlace de la función. ✅
host.json Configuración global para todas las funciones de la aplicación. ✅
requirements.txt Python dependencias instaladas durante la publicación cuando se usa remote build. (recomendado para la administración de paquetes)
local.settings.json Configuración y secretos de la aplicación solo local (nunca se publica). (necesario para el desarrollo local)
.funcignore Especifica archivos y carpetas que se van a excluir de la implementación (por ejemplo, , , ). (recomendado)
.venv/ Entorno virtual local para Python (excluido de la implementación). ❌
.vscode/ Configuración del editor para Visual Studio Code. No es necesario para la implementación. ❌
shared/ Contiene código auxiliar compartido en el proyecto de Aplicación de funciones ❌
additional_functions/ Se usa para la organización de código modular, normalmente con planos técnicos. ❌
tests/ Pruebas unitarias para la aplicación de funciones. No se ha publicado en Azure. ❌
Dockerfile Define un contenedor personalizado para la implementación. ❌

En el modelo de programación de Python v2, Azure Functions usa un enfoque basado en decorator para definir desencadenadores y enlaces directamente en el código. Cada función se implementa como un método global sin estado dentro de un archivo.

Ejemplo

Esta es una función sencilla que responde a una solicitud HTTP:

import azure.functions as func

app = func.FunctionApp()

@app.route("hello")
def http_trigger(req):
    user = req.params.get("user")
    return f"Hello, {user}!"

# requirements.txt
azure-functions

Conceptos clave

  • El código importa el paquete y usa decoradores y tipos para definir la aplicación de funciones.
  • La función tiene un único desencadenador HTTP.
  • El objeto HttpRequest contiene encabezados de solicitud, parámetros de consulta, parámetros de ruta y el cuerpo del mensaje. Esta función obtiene el valor del parámetro de consulta desde el parámetro del objeto HttpRequest.
  • Para enviar un nombre en este ejemplo, anexe a la dirección URL de la función expuesta. Por ejemplo, si se ejecuta localmente, la dirección URL completa podría ser similar a . Para obtener ejemplos de uso de enlaces, consulte Desencadenadores y enlaces.

La biblioteca

La biblioteca azure-functions Python es una parte fundamental del modelo de programación de Azure Functions. Proporciona los decoradores, los tipos de desencadenador y enlace, y los objetos de solicitud y respuesta usados para definir e interactuar con funciones en tiempo de ejecución. Para ver todos los tipos y decoradores disponibles, visite la API. El código de la aplicación de funciones depende de esta biblioteca para:

  • Definir todas las funciones mediante el objeto
  • Declarar desencadenadores y enlaces (por ejemplo, , )
  • Acceder a entradas y salidas tipadas (como y , y 'Out')

debe incluirse en las dependencias del proyecto. Para más información, consulte Administración de paquetes.

Nota:

La biblioteca azure-functions define la superficie de programación para Python Azure Functions, pero no es un SDK de uso general. Úselo específicamente para crear y ejecutar funciones dentro del entorno de ejecución de Azure Functions.

Usa anotaciones de tipo para mejorar el soporte de IntelliSense y del editor:

def http_trigger(req: func.HttpRequest) -> str:

Organización con planos técnicos

Para aplicaciones más grandes o modulares, use blueprints para definir funciones en archivos Python independientes y registrarlas en la aplicación principal. Esta separación mantiene el código organizado y reutilizable.

Para definir y registrar un plano técnico:

  1. Defina un plano técnico en otro archivo de Python, como http_blueprint.py:

    import azure.functions as func

bp = func.Blueprint()

@bp.route(route="default_template")
def default_template(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("Hello World!")

  2. Registre el esquema en el archivo principal .

    import azure.functions as func
from http_blueprint import bp

app = func.FunctionApp()
app.register_functions(bp)

Mediante planos técnicos, puede hacer lo siguiente:

  • Dividir la aplicación en módulos reutilizables
  • Mantener las funciones relacionadas agrupadas por archivo o característica
  • Extensión o uso compartido de planos técnicos entre proyectos

Nota:

Durable Functions también admite planos técnicos mediante azure-functions-durable. View →

Estructura de carpetas

Use la siguiente estructura para un proyecto de Python Azure Functions:

<project_root>/
│
├── .venv/                   # (Optional) Local Python virtual environment
├── .vscode/                 # (Optional) VS Code workspace settings
│
├── function_app.py          # Main function entry point (decorator model)
├── shared/                  # (Optional) Pure helper code with no triggers/bindings
│   └── utils.py
│
├── additional_functions/    # (Optional) Contains blueprints for organizing related Functions
│   └── blueprint_1.py  
│
├── tests/                   # (Optional) Unit tests for your functions
│   └── test_my_function.py
│
├── .funcignore              # Excludes files from being published
├── host.json                # Global function app configuration
├── local.settings.json      # Local-only app settings (not published)
├── requirements.txt         # (Optional) Defines Python dependencies for remote build
├── Dockerfile               # (Optional) For custom container deployment

Archivos y carpetas de claves

Archivo/carpeta Descripción Necesario para que la aplicación se ejecute en Azure
function_app.py Script principal donde se definen Azure Functions y desencadenadores mediante decoradores. ✅
host.json Configuración global para todas las funciones de la aplicación. ✅
requirements.txt Python dependencias instaladas durante la publicación cuando se usa remote build. (recomendado para la administración de paquetes)
local.settings.json Configuración y secretos de la aplicación solo local (nunca se publica). (necesario para el desarrollo local)
.funcignore Especifica archivos y carpetas que se van a excluir de la implementación (por ejemplo, , , ). (recomendado)
.venv/ Entorno virtual local para Python (excluido de la implementación). ❌
.vscode/ Configuración del editor para Visual Studio Code. No es necesario para la implementación. ❌
shared/ Contiene código auxiliar compartido en el proyecto de Aplicación de funciones ❌
additional_functions/ Se usa para la organización de código modular, normalmente con planos técnicos. ❌
tests/ Pruebas unitarias para la aplicación de funciones. No se ha publicado en Azure. ❌
Dockerfile Define un contenedor personalizado para la implementación. ❌

[NOTA!] Incluya un archivo al implementar con la compilación remota. Si no usa la compilación remota o quiere usar otro archivo para definir las dependencias de la aplicación, puede realizar una compilación local e implementar la aplicación con dependencias pregeneradas.

Para obtener instrucciones sobre las pruebas unitarias, consulte Pruebas unitarias. Para las implementaciones de contenedores, consulte Implementación con contenedores personalizados.

Desencadenadores y enlaces

Azure Functions usa triggers para iniciar la ejecución de funciones y bindings para conectar el código a otros servicios como almacenamiento, colas y bases de datos. En el modelo de programación de Python v2, se declaran enlaces mediante decoradores.

Existen dos tipos principales de enlaces:

  • Desencadenadores (entrada que inicia la función)
  • Entradas y salidas (orígenes de datos o destinos adicionales)

Para obtener más información sobre los desencadenadores y enlaces disponibles, consulte Triggers and Bindings in Azure Functions.

Ejemplo: desencadenador de temporizador con entrada de blob

Esta función:

  • Desencadenadores cada 10 minutos
  • Lee de un blob usando enlaces de tipo de SDK.
  • Almacena en caché los resultados y escribe en un archivo temporal
import azure.functions as func
import azurefunctions.extensions.bindings.blob as blob
import logging
import tempfile

CACHED_BLOB_DATA = None

app = func.FunctionApp()

@app.function_name(name="TimerTriggerWithBlob")
@app.schedule(schedule="0 */10 * * * *", arg_name="mytimer")
@app.blob_input(arg_name="client",
                path="PATH/TO/BLOB",
                connection="BLOB_CONNECTION_SETTING")
def timer_trigger_with_blob(mytimer: func.TimerRequest,
                            client: blob.BlobClient,
                            context: func.Context) -> None:
    global CACHED_BLOB_DATA
    if CACHED_BLOB_DATA is None:
        # Download blob and save as a global variable
        CACHED_BLOB_DATA = client.download_blob().readall()

        # Create temp file prefix
        my_prefix = context.invocation_id
        temp_file = tempfile.NamedTemporaryFile(prefix=my_prefix)
        temp_file.write(CACHED_BLOB_DATA)
        logging.info(f"Cached data written to {temp_file.name}")

Conceptos clave

  • Utilice vinculaciones de tipo de SDK para trabajar con tipos complejos. Para más información, consulte Enlaces de tipos de SDK.
  • Puede usar variables globales para almacenar en caché cálculos costosos, pero no se garantiza que su estado persista en las ejecuciones de funciones.
  • Los archivos temporales se almacenan en y no se garantiza que se conserven entre invocaciones o instancias de escalabilidad horizontal.
  • Puede acceder al contexto de invocación de una función a través de la clase Context.

Ejemplo: Desencadenador HTTP con entrada de Cosmos DB y salida del centro de eventos

Esta función:

  • Desencadenadores en una solicitud HTTP
  • Lee de una instancia de Cosmos DB
  • Escribe en una salida de Event Hub
  • Devuelve una respuesta HTTP.
# __init__.py
import azure.functions as func

def main(req: func.HttpRequest,
         documents: func.DocumentList,
         event: func.Out[str]) -> func.HttpResponse:

    # Content from HttpRequest and Cosmos DB input
    http_content = req.params.get("body")
    doc_id = documents[0]["id"] if documents else "No documents found"

    event.set(f"HttpRequest content: {http_content} | CosmosDB ID: {doc_id}")

    return func.HttpResponse(
        "Function executed successfully.",
        status_code=200
    )

// function.json
{
  "scriptFile": "__init__.py",
  "entryPoint": "main",
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": ["get", "post"],
      "route": "file"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "cosmosDB",
      "direction": "in",
      "name": "documents",
      "databaseName": "test",
      "containerName": "items",
      "id": "cosmosdb-input-test",
      "connection": "COSMOSDB_CONNECTION_SETTING"
    },
    {
      "type": "eventHub",
      "direction": "out",
      "name": "event",
      "eventHubName": "my-test-eventhub",
      "connection": "EVENTHUB_CONNECTION_SETTING"
    }
  ]
}

Conceptos clave

  • Cada función tiene un único desencadenador, pero puede tener varios enlaces.
  • Agregue entradas especificando el como "in" en . Las salidas tienen un de .
  • Puede acceder a los detalles de la solicitud a través del objeto y construir un personalizado con encabezados, código de estado y cuerpo.
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="HttpTriggerWithCosmosDB")
@app.route(route="file")
@app.cosmos_db_input(arg_name="documents",
                     database_name="test",
                     container_name="items",
                     connection="COSMOSDB_CONNECTION_SETTING")
@app.event_hub_output(arg_name="event",
                      event_hub_name="my-test-eventhub",
                      connection="EVENTHUB_CONNECTION_SETTING")
def http_trigger_with_cosmosdb(req: func.HttpRequest,
                               documents: func.DocumentList,
                               event: func.Out[str]) -> func.HttpResponse:
    # Content from HttpRequest and Cosmos DB input
    http_content = req.params.get('body')
    doc_id = documents[0]['id']

    event.set("HttpRequest content: " + http_content
              + " | CosmosDB ID: " + doc_id)

    return func.HttpResponse(
        f"Function executed successfully.",
        status_code=200
    )

Conceptos clave

  • Utilice o decoradores específicos del desencadenador, como , , y otros, para definir cómo se invoca la función.
  • Agregue entradas mediante decoradores como , y otros.
  • Las salidas pueden ser:
    • Se devuelve directamente (si solo hay una salida)
    • Se asigna mediante enlaces de y el método para varias salidas.
  • Puede acceder a los detalles de la solicitud a través del objeto y construir un personalizado con encabezados, código de estado y cuerpo.

Enlaces de tipos de SDK

Para seleccionar desencadenadores y enlaces, puede trabajar con tipos de datos implementados por los marcos y SDK de Azure subyacentes. Con estos enlaces de tipo de SDK, puede interactuar con los datos de enlace como si usara el SDK de servicio subyacente. Para obtener más información, consulte Enlaces de tipo de SDK admitidos.

Importante

La compatibilidad con enlaces de tipos de SDK para Python solo está disponible en el modelo de programación de Python v2.

Variables de entorno

Las variables de entorno de Azure Functions permiten administrar de forma segura los valores de configuración, las cadenas de conexión y los secretos de aplicación sin codificarlos de forma rígida en el código de función.

Puede definir variables de entorno:

  • Localmente: en el archivolocal.settings.json, durante el desarrollo local.
  • En Azure: como Configuración de aplicación en la página de configuración de function App en el portal de Azure.

Acceda a las variables directamente en el código mediante o .

setting_value = os.getenv("myAppSetting", "default_value")

Nota:

Azure Functions también reconoce las variables de entorno del sistema que configuran el tiempo de ejecución de Functions y Python comportamiento de trabajo. Estas variables no se usan explícitamente en el código de función, pero afectan a cómo se ejecuta la aplicación. Para obtener una lista completa de las variables de entorno del sistema, consulte Referencia de configuración de la aplicación.

Administración de paquetes

Para usar otros paquetes de Python en la aplicación de Azure Functions, enumerelos en un archivo /> Build Options for Python Function Apps.

Por ejemplo, en el ejemplo siguiente se muestra cómo se incluye y usa el módulo en la aplicación de funciones.

<requirements.txt>
requests==2.31.0

Instale el paquete localmente con .

Una vez instalado el paquete, puede importarlo y usarlo en el código de función:

import azure.functions as func
import requests

def main(req: func.HttpRequest) -> func.HttpResponse:
    r = requests.get("https://api.github.com")
    return func.HttpResponse(f"Status: {r.status_code}")

import azure.functions as func
import requests

app = func.FunctionApp()

@app.function_name(name="HttpExample")
@app.route(route="call_api")
def main(req: func.HttpRequest) -> func.HttpResponse:
    r = requests.get("https://api.github.com")
    return func.HttpResponse(f"Status: {r.status_code}")

Consideraciones

  • Conflictos con módulos integrados:
    • Evite asignar nombres a las carpetas del proyecto después de Python bibliotecas estándar (por ejemplo, email/, json/).
    • No incluya bibliotecas nativas de Python (como logging, asyncio o uuid) en requirements.txt.
  • Despliegue:
    • Para evitar errores, asegúrese de que todas las dependencias necesarias aparecen en .
    • Si actualiza la versión de Python de la aplicación, recompile y vuelva a implementar la aplicación en la nueva versión de Python para evitar conflictos de dependencia con paquetes creados previamente.
  • Dependencias no disponibles en PyPI:
    • Puede incluir dependencias que no están disponibles en PyPI en la aplicación, como paquetes locales, archivos de rueda o fuentes privadas. Consulte Dependencias decustom en Python Azure Functions para obtener instrucciones de configuración.
  • Azure Functions Python dependencias de trabajo:
    • Si el paquete contiene determinadas bibliotecas que podrían colisionar con las dependencias del trabajo (por ejemplo, o ), configure PYTHON_ISOLATE_WORKER_DEPENDENCIES en 1 en la configuración de la aplicación para evitar que la aplicación haga referencia a las dependencias del trabajo. Para Python 3.13 y versiones posteriores, este característica está habilitada de forma predeterminada.

Ejecución e implementación

En esta sección se proporciona información sobre running funciones localmente, Python compatibilidad con versiones, opciones de compilación e implementación y configuración en tiempo de ejecución. Use esta información para ejecutar correctamente la aplicación de funciones en entornos locales y Azure.

Ejecución local

Puede ejecutar y probar la aplicación de funciones de Python en el equipo local antes de realizar la implementación en Azure.

Uso de Azure Functions Core Tools

Instale Azure Functions Core Tools e inicie el entorno de ejecución local ejecutando el comando func start desde la raíz del proyecto:

func start

Al iniciar la aplicación de funciones localmente, Core Tools muestra todas las funciones que encuentra para la aplicación:

Functions:
        http_trigger:  http://localhost:7071/api/http_trigger

Para obtener más información sobre cómo usar Core Tools, visite Develop Azure Functions localmente mediante Core Tools.

Invocar la función directamente

Mediante azure-functions >= 1.21.0, también puede llamar a funciones directamente mediante el intérprete de Python sin ejecutar Core Tools. Este enfoque es útil para las pruebas unitarias rápidas:

# function_app.py
import azure.functions as func

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.route(route="http_trigger")
def http_trigger(req: func.HttpRequest) -> func.HttpResponse:
    return "Hello, World!"

# Test the function directly
print(http_trigger(None))

Para ver la salida, ejecute el archivo directamente con Python:

> python function_app.py

Hello, World!

# __init__.py
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    return func.HttpResponse("Hello, World!")

# Test the function directly
print(main(None))

Para ver la salida, ejecute el archivo directamente con Python:

> python __init__.py

Hello, World!

Este enfoque no requiere ningún paquete adicional ni configuración y es ideal para la validación rápida durante el desarrollo. Para obtener pruebas más detalladas, consulte Pruebas unitarias.

Versiones de Python admitidas

Azure Functions admite las versiones de Python enumeradas en Idiomas admitidos en Azure Functions. Para obtener más información general, consulte la directiva de soporte técnico en tiempo de ejecución Azure Functions.

Importante

Si cambia la versión de Python de la aplicación de funciones, debe volver a compilar y volver a implementar la aplicación mediante la nueva versión. Los artefactos y dependencias de implementación existentes no se vuelven a generar automáticamente cuando cambia la versión de Python.

Compilación e implementación

Para obtener más información sobre el mecanismo de compilación recomendado para su escenario, consulte Opciones de compilación. Para obtener información general sobre la implementación, consulte Tecnologías de implementación en Azure Functions.

Comparación rápida de mecanismos de implementación

Herramienta/Plataforma Comando o acción Mejor caso de uso
Azure Functions Core Tools func azure functionapp publish <APP_NAME> Ideal para las ejecuciones de CI, la automatización local o cuando se trabaja entre plataformas.
CLI de AZ az functionapp deployment source config-zip Resulta útil al crear scripts de implementaciones fuera de Core Tools. Funciona bien en canalizaciones automatizadas o terminales basados en la nube (Azure Cloud Shell).
Visual Studio Code (extensión Azure Functions) Comand Palette → "Azure Functions: Deploy to Azure..." Ideal para principiantes o implementaciones interactivas. Gestiona automáticamente el empaquetado y la compilación.
Acciones de GitHub Azure/functions-action@v1 Ideal para CI/CD basado en GitHub. Habilita las implementaciones automatizadas en combinaciones de inserción o PR.
Azure Pipelines tarea CI/CD empresarial mediante Azure DevOps. Ideal para flujos de trabajo de versión controlados, compilaciones controladas y canalizaciones de varias fases.
Despliegue de contenedor personalizado Insertar contenedor → Necesario cuando necesite paquetes de nivel de sistema operativo, compilaciones de Python personalizadas, entornos de ejecución anclados o dependencias no admitidas (por ejemplo, bibliotecas del sistema, archivos binarios locales).
Creación de funciones basadas en el portal Cree la función en el portal Azure → en el editor insertado. Use solo para funciones sencillas y sin dependencias. Ideal para demostraciones o aprendizaje, pero no se recomienda para las aplicaciones que requieren paquetes de terceros.

Nota:

La creación de funciones basada en el portal no admite dependencias de terceros y no se recomienda para crear aplicaciones de producción. No puede instalar ni hacer referencia a paquetes fuera de azure-functions y la biblioteca estándar de Python integrada.

Importante

Después del 30 de septiembre de 2028, se eliminará la opción de alojar tu app de funciones en Linux en un plan de consumo. Para evitar interrupciones, migre las aplicaciones del plan de consumo existentes que se ejecutan en Linux al plan de consumo flexible antes de esa fecha. Las aplicaciones que se ejecutan en Windows en un plan de consumo no se ven afectadas por este cambio.

Después del 30 de septiembre de 2025, no se añadirán nuevas características ni se ofrecerá compatibilidad con nuevas pilas de lenguajes en el plan de consumo de Linux. Las últimas versiones de lenguaje compatibles para el consumo de Linux son: .NET 9, Python 3.12, Node.js 22, PowerShell 7.4 y Java 21. Las versiones más recientes del lenguaje no se admiten para el consumo de Linux.

Para obtener más información, consulte Migración de aplicaciones de plan de consumo al plan de consumo flexible.

actualizaciones de Python 3.13+

A partir de Python 3.13, Azure Functions presenta varias mejoras importantes en tiempo de ejecución y rendimiento que afectan a cómo se compilan y ejecutan las aplicaciones. Entre los cambios clave se incluyen los siguientes:

  • Control de versiones en tiempo de ejecución: ahora puede anclar o actualizar la aplicación a versiones de trabajo específicas de Python haciendo referencia al paquete azure-functions-runtime en la requirements.txt.

    • Sin el control de versiones habilitado, la aplicación se ejecuta en una versión predeterminada del entorno de ejecución de Python, que Functions administra. Debe modificar el archivo requirements.txt para solicitar la versión más reciente publicada, una versión preliminar o para anclar la aplicación a una versión específica del entorno de ejecución de Python.

    • Para habilitar el control de versiones en tiempo de ejecución, agregue una referencia al paquete en tiempo de ejecución de Python al archivo requirements.txt, donde el valor asignado al paquete determina la versión en tiempo de ejecución usada.

    • Evite anclar cualquier aplicación de producción a versiones preliminares (alfa, beta o desarrollo).

    • Para tener en cuenta los cambios, revise Python notas de la versión del entorno de ejecución periódicamente.

    • En la tabla siguiente se indica el comportamiento de control de versiones en función del valor de versión de esta configuración en el archivo derequirements.txt :

      Versión Example Comportamiento
      No hay ningún conjunto de valores azure-functions-runtime La aplicación Python 3.13+ se ejecuta en la versión más reciente disponible de Functions Python runtime. Esta opción es mejor para mantenerse al día con las mejoras y características de la plataforma, ya que la aplicación recibe automáticamente las últimas actualizaciones estables en tiempo de ejecución.
      Anclado a una versión específica azure-functions-runtime==1.2.0 La aplicación Python 3.13+ permanece en la versión en tiempo de ejecución anclada y no recibe actualizaciones automáticas. En su lugar, debe actualizar manualmente la versión anclada para aprovechar las nuevas funcionalidades, correcciones y mejoras del entorno de ejecución. Se recomienda anclar las cargas de trabajo de producción críticas en las que la estabilidad y la previsibilidad son esenciales. Anclar también le permite probar la aplicación en versiones preliminares del entorno de ejecución durante el desarrollo.
      Sin referencia de paquete n/a Al no establecer el azure-functions-runtime, la aplicación Python 3.13+ se ejecuta en una versión predeterminada del entorno de ejecución de Python que está detrás de la versión más reciente publicada. Functions realiza periódicamente actualizaciones. Esta opción garantiza la estabilidad y una amplia compatibilidad. Sin embargo, el acceso a las características y correcciones más recientes se retrasa hasta que se actualice la versión predeterminada.

  • Aislamiento de dependencias: las dependencias de la aplicación (como o ) están completamente aisladas de las dependencias del trabajo, lo que impide conflictos de versiones. La configuración de la aplicación PYTHON_ISOLATE_WORKER_DEPENDENCIES no tendrá ningún impacto en las aplicaciones que se ejecutan en Python 3.13 o posterior.

  • Configuración simplificada de streaming HTTP : no se requiere ninguna configuración especial de la aplicación.

  • Se ha quitado el soporte para las extensiones de trabajo y las características de memoria compartida.

  • Control de versiones en tiempo de ejecución: ahora puede anclar o actualizar la aplicación a versiones de trabajo específicas de Python haciendo referencia al paquete azure-functions-runtime-v1 en la requirements.txt.

    • Sin el control de versiones habilitado, la aplicación se ejecuta en una versión predeterminada del entorno de ejecución de Python, que Functions administra. Debe modificar el archivo requirements.txt para solicitar la versión más reciente publicada, una versión preliminar o para anclar la aplicación a una versión específica del entorno de ejecución de Python.

    • Para habilitar el control de versiones en tiempo de ejecución, agregue una referencia al paquete en tiempo de ejecución de Python al archivo requirements.txt, donde el valor asignado al paquete determina la versión en tiempo de ejecución usada.

    • Evite anclar cualquier aplicación de producción a versiones preliminares (alfa, beta o desarrollo).

    • Para tener en cuenta los cambios, revise Python notas de la versión del entorno de ejecución periódicamente.

    • En la tabla siguiente se indica el comportamiento de control de versiones en función del valor de versión de esta configuración en el archivo derequirements.txt :

      Versión Example Comportamiento
      No hay ningún conjunto de valores azure-functions-runtime-v1 La aplicación Python 3.13+ se ejecuta en la versión más reciente disponible de Functions Python runtime. Esta opción es mejor para mantenerse al día con las mejoras y características de la plataforma, ya que la aplicación recibe automáticamente las últimas actualizaciones estables en tiempo de ejecución.
      Anclado a una versión específica azure-functions-runtime-v1==1.2.0 La aplicación Python 3.13+ permanece en la versión en tiempo de ejecución anclada y no recibe actualizaciones automáticas. En su lugar, debe actualizar manualmente la versión anclada para aprovechar las nuevas funcionalidades, correcciones y mejoras del entorno de ejecución. Se recomienda anclar las cargas de trabajo de producción críticas en las que la estabilidad y la previsibilidad son esenciales. Anclar también le permite probar la aplicación en versiones preliminares del entorno de ejecución durante el desarrollo.
      Sin referencia de paquete n/a Al no establecer el azure-functions-runtime-v1, la aplicación Python 3.13+ se ejecuta en una versión predeterminada del entorno de ejecución de Python que está detrás de la versión más reciente publicada. Functions realiza periódicamente actualizaciones. Esta opción garantiza la estabilidad y una amplia compatibilidad. Sin embargo, el acceso a las características y correcciones más recientes se retrasa hasta que se actualice la versión predeterminada.

  • Aislamiento de dependencias: las dependencias de la aplicación (como o ) están completamente aisladas de las dependencias del trabajo, lo que impide conflictos de versiones. La configuración de la aplicación PYTHON_ISOLATE_WORKER_DEPENDENCIES no tendrá ningún impacto en las aplicaciones que se ejecutan en Python 3.13 o posterior.

  • Se ha quitado el soporte para las extensiones de trabajo y las características de memoria compartida.

Observabilidad y pruebas

En esta sección se tratan logging, monitoring y testing para ayudarle a depurar problemas, realizar un seguimiento del rendimiento y garantizar la confiabilidad de las aplicaciones de funciones de Python.

Registro y supervisión

Azure Functions expone un registrador raíz que puede usar directamente con el módulo integrado logging de Python. Los mensajes escritos con este registrador se envían automáticamente a Application Insights cuando la aplicación se ejecuta en Azure.

El registro permite capturar información en tiempo de ejecución y diagnosticar problemas sin necesidad de configurar más.

Ejemplo de registro con un desencadenador HTTP

import logging
import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    logging.debug("Example debug log")
    logging.info("Example info log")
    logging.warning("Example warning")
    logging.error("Example error log")
    return func.HttpResponse("OK")

import logging
import azure.functions as func

app = func.FunctionApp()

@app.route(route="http_trigger")
def http_trigger(req) -> func.HttpResponse:
    logging.debug("Example debug log")
    logging.info("Example info log")
    logging.warning("Example warning")
    logging.error("Example error log")
    return func.HttpResponse("OK")

Puede usar el conjunto completo de niveles de registro (debug, info, warning, error, critical) y aparecen en el portal de Azure en Registros o Application Insights.

Para obtener más información sobre la supervisión de Azure Functions en el portal, consulte Monitor Azure Functions.

Nota:

Para ver los registros de depuración en Application Insights, se requieren más ajustes. Puede habilitar esta característica estableciendo PYTHON_ENABLE_DEBUG_LOGGING a y estableciendo a o en el archivo host.json. De forma predeterminada, los registros de depuración no están visibles en Application Insights.

Registro desde subprocesos en segundo plano

Si la función inicia un nuevo subproceso y necesita iniciar sesión desde ese subproceso, asegúrese de pasar el argumento al subproceso. contiene el almacenamiento local de subprocesos y el actual , que se debe establecer en el subproceso de trabajo para que los registros se asocien correctamente a la ejecución de la función.

import logging
import threading
import azure.functions as func

def main(req: func.HttpRequest, context) -> func.HttpResponse:
    logging.info("Function started")
    t = threading.Thread(target=log_from_thread, args=(context,))
    t.start()
    return "okay"

def log_from_thread(context):
    # Associate the thread with the current invocation
    context.thread_local_storage.invocation_id = context.invocation_id  
    logging.info("Logging from a background thread")

import azure.functions as func
import logging
import threading

app = func.FunctionApp()

@app.route(route="http_trigger")
def http_trigger(req, context) -> func.HttpResponse:
    logging.info("Function started")
    t = threading.Thread(target=log_from_thread, args=(context,))
    t.start()
    return "okay"

def log_from_thread(context):
    # Associate the thread with the current invocation
    context.thread_local_storage.invocation_id = context.invocation_id  
    logging.info("Logging from a background thread")

Configuración de registradores personalizados

Puede configurar registradores personalizados en Python cuando necesite más control sobre el comportamiento de registro, como formato personalizado, filtrado de registros o integraciones de terceros. Para configurar un registrador personalizado, use el logging.getLogger() de Python con un nombre personalizado y agregue controladores o formateadores según sea necesario.

import logging

custom_logger = logging.getLogger('my_custom_logger')

Compatibilidad con OpenTelemetry

Azure Functions para Python también admite OpenTelemetry, lo que permite emitir seguimientos, métricas y registros en un formato estandarizado. El uso de OpenTelemetry es especialmente útil para aplicaciones distribuidas o escenarios en los que desea exportar datos de telemetría a herramientas fuera de Application Insights (como Grafana o Jaeger).

Consulte nuestro inicio rápido de OpenTelemetry para obtener Azure Functions (Python) para obtener instrucciones de configuración y código de ejemplo.

Pruebas unitarias

Escriba y ejecute pruebas unitarias para las funciones mediante . Puede probar Python funciones como otro código de Python mediante marcos de pruebas estándar. Para la mayoría de los enlaces, puede crear un objeto de entrada ficticio creando una instancia de una clase adecuada del paquete .

Mediante el uso de como ejemplo, el ejemplo siguiente es una prueba ficticia de una función desencadenada por HTTP:

En primer lugar, cree el archivo project_root/function_app.py e implemente la función como desencadenador HTTP.

# <project_root>/function_app.py
import azure.functions as func
import logging

app = func.FunctionApp()

# Define the HTTP trigger that accepts the ?value=<int> query parameter
# Double the value and return the result in HttpResponse
@app.function_name(name="my_function")
@app.route(route="hello")
def my_function(req: func.HttpRequest) -> func.HttpResponse:
    logging.info('Executing myfunction.')

    initial_value: int = int(req.params.get('value'))
    doubled_value: int = initial_value * 2

    return func.HttpResponse(
        body=f"{initial_value} * 2 = {doubled_value}",
        status_code=200
    )

Puede empezar a escribir casos de prueba para el desencadenador HTTP.

# <project_root>/test_my_function.py
import unittest
import azure.functions as func

from function_app 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/my_function',
                           params={'value': '21'})
    # Call the function.
    func_call = main.build().get_user_function()
    resp = func_call(req)
    # Check the output.
    self.assertEqual(
        resp.get_body(),
        b'21 * 2 = 42',
    )

Dentro de la carpeta Python entorno virtual, puede ejecutar los siguientes comandos para probar la aplicación:

pip install pytest
pytest test_my_function.py

Verá los resultados en el terminal, de la siguiente manera:

============================================================================================================ test session starts ============================================================================================================
collected 1 item                                                                                                                                                                                                                             

test_my_function.py .                                                                                                                                                                                                                  [100%] 
============================================================================================================= 1 passed in 0.24s =============================================================================================================

Optimización y temas avanzados

Para más información sobre cómo optimizar las aplicaciones de funciones de Python, consulte estos artículos:

Para obtener más información sobre Functions, consulte estos artículos:

¿Tiene problemas con el uso de Python? Háganoslo saber y reporte un problema.

  • Last updated on