Persistencia y serialización de datos en Durable Functions para Azure Functions

Importante

El soporte técnico del modelo en proceso finalizará el 10 de noviembre de 2026. Se recomienda encarecidamente migrar las aplicaciones al modelo de trabajo aislado para obtener soporte técnico completo.

El tiempo de ejecución de Durable Functions persiste automáticamente los parámetros de función, los valores devueltos y otros estados en el centro de tareas para proporcionar una ejecución confiable. Sin embargo, la cantidad y la frecuencia de los datos que persisten en el almacenamiento duradero pueden afectar al rendimiento de las aplicaciones y a los costos de las transacciones de almacenamiento. En función del tipo de datos que almacene una aplicación, es posible que también sea necesario tener en cuenta la retención de datos y las directivas de privacidad.

En este artículo se explica qué datos se conservan, cómo controlar cargas grandes y datos confidenciales, y cómo personalizar la serialización para cada idioma admitido.

En este artículo:

• Contenido del centro de tareas: qué datos se almacenan y cómo
• Mantener pequeñas entradas y salidas : estrategias para administrar el tamaño de la carga
• Trabajar con datos confidenciales : protección de secretos e información de identificación personal
• Protección del almacenamiento del centro de tareas : protección del back-end de almacenamiento frente al acceso no autorizado
• Personalizar la serialización y la deserialización : opciones de serialización específicas del lenguaje

Contenido del centro de tareas

Las centrales de tareas almacenan el estado actual de las instancias y los mensajes pendientes:

• Los estados de instancia almacenan el estado actual y el historial de una instancia. En el caso de las instancias de orquestación, esto incluye el estado del runtime, el historial de orquestación, las entradas, las salidas y el estado personalizado. En el caso de las instancias de entidad, incluye el estado de la entidad.
• Los mensajes almacenan entradas o salidas de función, cargas de eventos y metadatos que se usan con fines internos, como el enrutamiento y la correlación de un extremo a otro.

Los mensajes se eliminan después de procesarse, pero los estados de instancia se conservan a menos que la aplicación o un operador los eliminen explícitamente. En concreto, un historial de orquestaciones permanece en el almacenamiento incluso después de que se completa la orquestación.

Para obtener un ejemplo de cómo los estados y los mensajes representan el progreso de una orquestación, consulte el ejemplo de ejecución de la central de tareas.

Dónde y cómo se representan los estados y los mensajes en el almacenamiento depende del proveedor de almacenamiento. Usa Durable Task Scheduler porque proporciona un backend gestionado para los centros de tareas y gestiona el almacén de estados subyacente por ti. Sin embargo, Azure Storage sigue siendo una opción sólida para cargas de trabajo existentes y para aplicaciones que quieren gestionar sus propios recursos de almacenamiento.

Proveedor de almacenamiento	Cómo se almacena el estado	Uso recomendado
Programador de tareas duraderas	La orquestación y el estado de la entidad se almacenan en el backend del planificador gestionado detrás de un recurso del hub de tareas.	Opción preferida para nuevas aplicaciones Durable Functions y despliegues gestionados.
Azure Storage	El estado y los mensajes se representan en colas, tablas y blobs en una cuenta de Azure Storage.	Es una buena opción para aplicaciones o despliegues existentes que ya dependen de Azure Storage.

Tipos de datos que se serializan y conservan

En la lista siguiente se muestran los diferentes tipos de datos que se serializarán y conservarán al usar las características de Durable Functions:

• Todas las entradas y salidas de las funciones de orquestador, actividad y entidad, incluidos los identificadores y las excepciones no controladas
• Nombres de las funciones de orquestador, actividad y entidad
• Nombres y cargas de eventos externos
• Cargas de estado de la orquestación personalizada
• Mensajes de finalización de orquestación
• Cargas de temporizador duraderas
• Direcciones URL de solicitud y respuesta HTTP duraderas, encabezados y cargas
• Cargas de llamadas y señales de entidades
• Cargas de estado de entidades

Para obtener instrucciones sobre cómo administrar el tamaño de carga y proteger elementos confidenciales en esta lista, consulte las secciones siguientes.

Mantener pequeñas entradas y salidas de Durable Functions

Puede encontrarse con problemas de memoria si proporciona entradas y salidas grandes hacia y desde las API de Durable Functions. Las entradas y salidas se serializan en el historial de orquestación, lo que significa que las cargas grandes pueden, con el tiempo, contribuir considerablemente al crecimiento ilimitado del historial. Este crecimiento corre el riesgo de causar excepciones de memoria durante la reproducción.

Para mitigar el impacto de las entradas y salidas grandes, puede hacer lo siguiente:

• Delegue el trabajo en suborquestadores para equilibrar la carga de memoria de los historiales entre varios orquestadores, manteniendo reducida la huella de memoria de los historiales individuales.
• Almacene datos grandes en el almacenamiento externo (como Azure Blob Storage) y pase identificadores ligeros que le permiten recuperar esos datos dentro de las funciones de actividad cuando sea necesario.

Para Durable Task Scheduler, utiliza la compatibilidad con cargas útiles de gran tamaño para transferir las cargas útiles más grandes a Azure Blob Storage. Para las aplicaciones nuevas, se recomienda este patrón cuando una orquestación debe transferir grandes volúmenes de datos entre operaciones duraderas. Si utilizas el proveedor de Azure Storage, aún puedes aplicar el patrón de verificación de reclamaciones mostrado en la siguiente sección y pasar referencias ligeras entre operaciones.

Tip

El procedimiento recomendado para tratar datos grandes es mantenerlo en el almacenamiento externo y materializar esos datos solo dentro de las actividades, cuando sea necesario.

Pasar referencias a cargas útiles de gran tamaño

Elige el patrón que se adapte a tu proveedor de almacenamiento.

Programador de tareas duraderas

Si usas Durable Task Scheduler, activa el soporte de cargas útiles grandes para que el entorno de ejecución escriba cargas útiles mayores en Azure Blob Storage y envíe una pequeña referencia a través del planificador. Una configuración típica se muestra en la documentación del planificador:

{
  "version": "2.0",
  "extensions": {
    "durableTask": {
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DTS_CONNECTION_STRING",
        "payloadStorageEnabled": true,
        "payloadStorageThresholdBytes": 262144
      },
      "hubName": "%TASKHUB_NAME%"
    }
  }
}

Azure Storage

Con el proveedor de Azure Storage, puedes usar el patrón Claim Check para mantener el historial de orquestación pequeño mientras sigues procesando cargas útiles grandes. El orquestador pasa una referencia ligera que contiene el contenedor y el nombre del blob, y la actividad lee o escribe la carga desde Azure Blob Storage según sea necesario.

Los siguientes ejemplos asumen que ya tienes un blob en tu cuenta de almacenamiento. Comienza la orquestación con una referencia como {"container":"large-payloads","blobName":"input/job-123.json"}. La actividad crea el processed-payloads contenedor de salida si es necesario. El paso de procesamiento de muestra copia los bytes de entrada sin cambios; Cámbiala por la lógica de tu aplicación.

Importante

Nunca incluyas credenciales de almacenamiento ni una firma de acceso compartido (SAS) en la referencia. El sistema sigue siendo la referencia en la historia de la orquestación. Estos ejemplos utilizan una configuración de aplicación llamada PAYLOAD_STORAGE_CONNECTION_STRING para mantener el código de almacenamiento conciso. Para cargas de trabajo en producción, utiliza Microsoft Entra ID para autorizar el acceso a datos de blobs.

C# (Aislado)

Este ejemplo requiere el paquete NuGet Azure.Storage.Blobs.

using System;
using System.Threading.Tasks;
using Azure.Storage.Blobs;
using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;

public record BlobReference(string Container, string BlobName);

public static class LargePayloadFunctions
{
    [Function("ProcessLargePayload")]
    public static async Task<BlobReference> RunOrchestrator(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        BlobReference inputReference = context.GetInput<BlobReference>()
            ?? throw new InvalidOperationException("A blob reference is required.");

        return await context.CallActivityAsync<BlobReference>(
            nameof(ProcessLargePayloadActivity), inputReference);
    }

    [Function(nameof(ProcessLargePayloadActivity))]
    public static async Task<BlobReference> ProcessLargePayloadActivity(
        [ActivityTrigger] BlobReference inputReference)
    {
        string connectionString =
            Environment.GetEnvironmentVariable("PAYLOAD_STORAGE_CONNECTION_STRING")
            ?? throw new InvalidOperationException("Payload storage is not configured.");
        BlobServiceClient service = new BlobServiceClient(connectionString);

        BlobClient inputBlob = service
            .GetBlobContainerClient(inputReference.Container)
            .GetBlobClient(inputReference.BlobName);
        BinaryData inputData = (await inputBlob.DownloadContentAsync()).Value.Content;

        BlobContainerClient outputContainer =
            service.GetBlobContainerClient("processed-payloads");
        await outputContainer.CreateIfNotExistsAsync();

        string outputName = $"processed/{Guid.NewGuid():N}.json";
        await outputContainer.GetBlobClient(outputName)
            .UploadAsync(inputData, overwrite: true);

        return new BlobReference(outputContainer.Name, outputName);
    }
}

C# (InProc)

Este ejemplo requiere el paquete NuGet Azure.Storage.Blobs.

using System;
using System.Threading.Tasks;
using Azure.Storage.Blobs;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;

public class BlobReference
{
    public string Container { get; set; } = string.Empty;
    public string BlobName { get; set; } = string.Empty;
}

public static class LargePayloadFunctions
{
    [FunctionName("ProcessLargePayload")]
    public static async Task<BlobReference> RunOrchestrator(
        [OrchestrationTrigger] IDurableOrchestrationContext context)
    {
        BlobReference inputReference = context.GetInput<BlobReference>()
            ?? throw new InvalidOperationException("A blob reference is required.");

        return await context.CallActivityAsync<BlobReference>(
            "ProcessLargePayloadActivity", inputReference);
    }

    [FunctionName("ProcessLargePayloadActivity")]
    public static async Task<BlobReference> RunActivity(
        [ActivityTrigger] BlobReference inputReference)
    {
        string connectionString =
            Environment.GetEnvironmentVariable("PAYLOAD_STORAGE_CONNECTION_STRING")
            ?? throw new InvalidOperationException("Payload storage is not configured.");
        BlobServiceClient service = new BlobServiceClient(connectionString);

        BlobClient inputBlob = service
            .GetBlobContainerClient(inputReference.Container)
            .GetBlobClient(inputReference.BlobName);
        BinaryData inputData = (await inputBlob.DownloadContentAsync()).Value.Content;

        BlobContainerClient outputContainer =
            service.GetBlobContainerClient("processed-payloads");
        await outputContainer.CreateIfNotExistsAsync();

        string outputName = $"processed/{Guid.NewGuid():N}.json";
        await outputContainer.GetBlobClient(outputName)
            .UploadAsync(inputData, overwrite: true);

        return new BlobReference
        {
            Container = outputContainer.Name,
            BlobName = outputName,
        };
    }
}

JavaScript

Este ejemplo requiere el paquete npm @azure/storage-blob .

const { randomUUID } = require("crypto");
const { BlobServiceClient } = require("@azure/storage-blob");
const df = require("durable-functions");

df.app.orchestration("processLargePayload", function* (context) {
    const inputReference = context.df.getInput();
    return yield context.df.callActivity(
        "processLargePayloadActivity", inputReference);
});

df.app.activity("processLargePayloadActivity", {
    handler: async (inputReference) => {
        const connectionString =
            process.env.PAYLOAD_STORAGE_CONNECTION_STRING;
        if (!connectionString) {
            throw new Error(
                "PAYLOAD_STORAGE_CONNECTION_STRING is not set.");
        }

        const service = BlobServiceClient.fromConnectionString(
            connectionString);

        const inputBlob = service
            .getContainerClient(inputReference.container)
            .getBlockBlobClient(inputReference.blobName);
        const inputData = await inputBlob.downloadToBuffer();

        const outputContainer =
            service.getContainerClient("processed-payloads");
        await outputContainer.createIfNotExists();

        const outputName = `processed/${randomUUID()}.json`;
        await outputContainer.getBlockBlobClient(outputName)
            .uploadData(inputData);

        return {
            container: outputContainer.containerName,
            blobName: outputName,
        };
    },
});

Python

Este ejemplo requiere el paquete azure-storage-blob . Añádelo a requirements.txt.

import os
import uuid

import azure.functions as func
import azure.durable_functions as df
from azure.core.exceptions import ResourceExistsError
from azure.storage.blob import BlobServiceClient

app = df.DFApp(http_auth_level=func.AuthLevel.ANONYMOUS)


@app.orchestration_trigger(context_name="context")
def process_large_payload(context: df.DurableOrchestrationContext):
    input_reference: dict = context.get_input()
    return (yield context.call_activity(
        "process_large_payload_activity", input_reference))


@app.activity_trigger(input_name="input_reference")
def process_large_payload_activity(input_reference: dict) -> dict:
    connection_string = os.getenv("PAYLOAD_STORAGE_CONNECTION_STRING")
    if not connection_string:
        raise ValueError(
            "PAYLOAD_STORAGE_CONNECTION_STRING is not set.")

    service = BlobServiceClient.from_connection_string(connection_string)

    input_blob = service.get_blob_client(
        container=input_reference["container"],
        blob=input_reference["blobName"])
    input_data = input_blob.download_blob().readall()

    output_container = service.get_container_client("processed-payloads")
    try:
        output_container.create_container()
    except ResourceExistsError:
        pass

    output_name = f"processed/{uuid.uuid4()}.json"
    output_container.upload_blob(
        name=output_name, data=input_data, overwrite=True)

    return {
        "container": output_container.container_name,
        "blobName": output_name,
    }

PowerShell

Este ejemplo requiere el módulo Az.Storage . Añádelo a requirements.psd1 y asegúrate de que las dependencias gestionadas estén habilitadas en host.json.

Orquestador run.ps1:

param($Context)

$OutputReference = Invoke-DurableActivity `
    -FunctionName 'ProcessLargePayloadActivity' `
    -Input $Context.Input

return $OutputReference

Actividad run.ps1:

param($InputReference)

if ([string]::IsNullOrEmpty(
        $env:PAYLOAD_STORAGE_CONNECTION_STRING)) {
    throw 'The PAYLOAD_STORAGE_CONNECTION_STRING app setting is not configured.'
}

$StorageContext = New-AzStorageContext `
    -ConnectionString $env:PAYLOAD_STORAGE_CONNECTION_STRING
$InputFile = New-TemporaryFile

try {
    Get-AzStorageBlobContent `
        -Container $InputReference.container `
        -Blob $InputReference.blobName `
        -Destination $InputFile.FullName `
        -Context $StorageContext `
        -Force | Out-Null

    # Process $InputFile here. This example uploads it unchanged.
    $OutputContainer = 'processed-payloads'
    New-AzStorageContainer `
        -Name $OutputContainer `
        -Context $StorageContext `
        -ErrorAction SilentlyContinue | Out-Null

    $OutputName = "processed/$([guid]::NewGuid()).json"
    Set-AzStorageBlobContent `
        -File $InputFile.FullName `
        -Container $OutputContainer `
        -Blob $OutputName `
        -Context $StorageContext `
        -Force | Out-Null

    return @{
        container = $OutputContainer
        blobName = $OutputName
    }
}
finally {
    Remove-Item $InputFile.FullName -Force
}

Utilice los enlaces estándar orchestrationTrigger y activityTrigger descritos en Enlaces de Durable Functions.

Java

Este ejemplo requiere los paquetes de Maven com.azure:azure-storage-blob y com.microsoft:durabletask-azure-functions.

import com.azure.core.util.BinaryData;
import com.azure.storage.blob.BlobContainerClient;
import com.azure.storage.blob.BlobServiceClient;
import com.azure.storage.blob.BlobServiceClientBuilder;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.durabletask.TaskOrchestrationContext;
import com.microsoft.durabletask.azurefunctions.DurableActivityTrigger;
import com.microsoft.durabletask.azurefunctions.DurableOrchestrationTrigger;

import java.util.Objects;
import java.util.UUID;

public class LargePayloadFunctions {
    public static class BlobReference {
        public String container;
        public String blobName;

        public BlobReference() {
        }

        public BlobReference(String container, String blobName) {
            this.container = container;
            this.blobName = blobName;
        }
    }

    @FunctionName("ProcessLargePayload")
    public BlobReference runOrchestrator(
            @DurableOrchestrationTrigger(name = "ctx")
            TaskOrchestrationContext ctx) {
        BlobReference inputReference = Objects.requireNonNull(
            ctx.getInput(BlobReference.class),
            "A blob reference is required.");
        return ctx.callActivity(
            "ProcessLargePayloadActivity",
            inputReference,
            BlobReference.class).await();
    }

    @FunctionName("ProcessLargePayloadActivity")
    public BlobReference runActivity(
            @DurableActivityTrigger(name = "inputReference")
            BlobReference inputReference) {
        String connectionString = Objects.requireNonNull(
            System.getenv("PAYLOAD_STORAGE_CONNECTION_STRING"),
            "PAYLOAD_STORAGE_CONNECTION_STRING is not configured.");
        BlobServiceClient service = new BlobServiceClientBuilder()
            .connectionString(connectionString)
            .buildClient();

        BinaryData inputData = service
            .getBlobContainerClient(inputReference.container)
            .getBlobClient(inputReference.blobName)
            .downloadContent();

        BlobContainerClient outputContainer =
            service.getBlobContainerClient("processed-payloads");
        outputContainer.createIfNotExists();

        String outputName =
            "processed/" + UUID.randomUUID() + ".json";
        outputContainer.getBlobClient(outputName)
            .upload(inputData, true);

        return new BlobReference(
            outputContainer.getBlobContainerName(), outputName);
    }
}

Si las actividades paralelas producen múltiples resultados grandes, devuelva una lista de referencias y pasa esa lista a una actividad final de agregación. La actividad de agregación debe cargar y combinar las cargas útiles y luego escribir un último blob de salida. No cargue ni concatene los resultados de gran tamaño en el orquestador.

Trabajar con datos confidenciales

Las entradas y salidas (incluidas las excepciones) a y desde las API de Durable Functions se conservan de forma duradera en el proveedor de storage que prefiera. Si esas entradas, salidas o excepciones contienen datos confidenciales (como secretos, cadenas de conexión o información de identificación personal), cualquier persona con acceso de lectura a los recursos del proveedor de almacenamiento podría obtenerlas.

Para manipular de forma segura los datos confidenciales, obtenga esos datos desde Azure Key Vault o variables de entorno dentro de las funciones de actividad, y nunca comunique esos datos directamente hacia o desde orquestadores o entidades. Este enfoque ayuda a evitar que los datos confidenciales se filtren en los recursos de almacenamiento.

Del mismo modo, el acceso de escritura a los recursos de almacenamiento debe controlarse estrechamente, ya que los datos alterados en el almacenamiento podrían modificar el comportamiento de la orquestación. Para obtener más información sobre cómo proteger el almacenamiento del centro de tareas, consulte Protección del almacenamiento del centro de tareas.

Tip

Esta guía también se aplica a la API de CallHttp orquestador, que conserva sus cargas de solicitud y respuesta en el almacenamiento. Si los puntos de conexión HTTP de destino requieren autenticación, implemente la llamada HTTP dentro de una actividad o use la compatibilidad integrada con identidad administrada ofrecida por CallHttp, que no conserva las credenciales en el almacenamiento.

Note

Evite registrar datos que contengan secretos, ya que cualquier persona con acceso de lectura a los registros (por ejemplo, en Application Insights) podría obtener esos secretos.

Cifrado en reposo

Al usar el proveedor Azure Storage, todos los datos se cifran automáticamente en reposo. Sin embargo, cualquier usuario con acceso a la cuenta de almacenamiento puede leer los datos en su formato no cifrado. Si necesita una protección más segura para datos confidenciales, considere la posibilidad de cifrar primero los datos con sus propias claves de cifrado para que los datos se conserven en su formato previamente cifrado.

Como alternativa, los usuarios de .NET tienen la opción de implementar proveedores de serialización personalizados que proporcionan cifrado automático. Puede encontrar un ejemplo de serialización personalizada con cifrado en este ejemplo de GitHub.

Note

Si decide implementar el cifrado a nivel de aplicación, tenga en cuenta que las orquestaciones y entidades pueden existir durante un período de tiempo indefinido. Esto es importante cuando llega el momento de rotar tus claves de cifrado, ya que una orquestación u otras entidades pueden operar durante más tiempo que tu política de rotación de claves. Si se produce una rotación de claves, es posible que la clave usada para cifrar los datos ya no esté disponible para descifrarlos la próxima vez que se ejecute la orquestación o entidad. Por lo tanto, se recomienda el cifrado personalizado solo cuando se espera que las orquestaciones y las entidades se ejecuten durante períodos de tiempo relativamente cortos.

Protección del almacenamiento del centro de tareas

El back-end de almacenamiento que hospeda el centro de tareas es un límite de confianza crítico. Durable Task Framework confía en los datos que lee del almacenamiento durante la reproducción de orquestación y el procesamiento de mensajes. Cualquier persona con acceso de escritura al almacenamiento del centro de tareas puede alterar el estado de orquestación, los mensajes pendientes o las cargas almacenadas. Esto puede modificar el comportamiento de la aplicación, desencadenar acciones no deseadas o lograr la ejecución remota de código en el contexto de la aplicación de funciones.

Importante

No exponga las credenciales de almacenamiento del centro de tareas ni conceda acceso de escritura a partes que no son de confianza. El acceso de escritura al almacenamiento del centro de tareas se puede usar para modificar el comportamiento de la aplicación, incluido el desencadenamiento de la ejecución arbitraria de código.

Responsabilidad compartida

Proteger el back-end de almacenamiento es responsabilidad suya, igual que proteger cualquier base de datos que almacene el estado o el código de la aplicación. Durable Task Framework no realiza la comprobación de integridad en los datos almacenados, por lo que se basa en los controles de acceso de la capa de almacenamiento para evitar modificaciones no autorizadas.

Backend	Responsabilidad en seguridad	Instrucciones
Programador de tareas duraderas	Microsoft gestiona el backend de almacenamiento subyacente. Gestionas identidades, acceso al centro de tareas y seguridad a nivel de aplicación.	Preferido por defecto para las nuevas aplicaciones de Durable Functions.
Azure Storage y otros proveedores BYO	Gestionas la cuenta de almacenamiento o base de datos y sus controles de seguridad.	Es un buen ajuste para cargas de trabajo o despliegues existentes que ya dependen de Azure Storage.

Note

No comparta un único centro de tareas entre inquilinos que no son de confianza. Un centro de tareas no aplica límites de acceso entre sus usuarios, por lo que cualquier inquilino que pueda leer o escribir en el centro de tareas puede afectar a todas las orquestaciones y entidades dentro de él. Del mismo modo, no se debe confiar en concentradores de tareas independientes dentro del mismo backend como límite de seguridad. Aunque Durable Task Scheduler admite RBAC con ámbito de centros de tareas individuales, los controles de red, como las listas de direcciones IP permitidas y los puntos de conexión privados, solo se aplican en el nivel de programador, por lo que los centros de tareas dentro de un programador no son un límite de aislamiento de seguridad. Lo mismo sucede con los proveedores de almacenamiento BYO: cualquier inquilino con acceso a la cuenta de almacenamiento o la base de datos puede llegar a todos los centros de tareas de ese back-end. Cuando necesite aislamiento de seguridad entre inquilinos, aprovisione una infraestructura independiente para cada inquilino: cuentas de almacenamiento independientes o bases de datos para proveedores BYO o instancias independientes del Programador de tareas durables.

Lista de comprobación de fortalecimiento del almacenamiento

Aplique los siguientes procedimientos recomendados para proteger el almacenamiento del centro de tareas:

• Utiliza conexiones basadas en la identidad para el backend que elijas.

  • Con Durable Task Scheduler, utilice identidades administradas y RBAC para el programador y los concentradores de tareas.
  • Con Azure Storage y otros proveedores BYO, prefiero la identidad gestionada sobre las cadenas de conexión siempre que sea posible.

  Consulte Configurar una identidad administrada para Durable Functions.

• Aplique roles RBAC con privilegios mínimos. Conceda solo los permisos mínimos necesarios. Evita conceder acceso amplio a almacenamiento a usuarios o servicios que no lo necesiten.

• Restringe el acceso de red a su cuenta de almacenamiento o a la implementación del programador mediante los puntos de conexión privados o puntos de conexión de servicio. Esta restricción ayuda a evitar el acceso no autorizado a nivel de red a los datos del centro de tareas.

• Supervise el acceso al almacenamiento para ello, habilite los registros de recursos de Azure Monitor en su cuenta de almacenamiento, especialmente la categoría de registro StorageWrite. Enrute estos registros a un destino fuera de la cuenta de almacenamiento supervisada, como Log Analytics, por lo que no se pueden manipular. Consulte Registros de almacenamiento.

• Rotar las credenciales periódicamente si usa cadenas de conexión. Trate las claves de la cuenta de almacenamiento con el mismo cuidado que cualquier otra credencial con privilegios elevados.

• Considere la posibilidad de usar un back-end de almacenamiento administrado. Durable Task Scheduler gestiona automáticamente la seguridad del almacenamiento, incluyendo autenticación, RBAC y aislamiento de red, mientras que Azure Storage ofrece un control explícito de almacenamiento.

Personalización de la serialización y deserialización

Las opciones de personalización de serialización varían según el idioma. Seleccione la pestaña idioma para ver las opciones disponibles.

C# (Aislado)

.NET aislado y System.Text.Json

Durable Functions que se ejecutan en el proceso de trabajo aislado de .NET utilizan el mismo serializador de objetos configurado globalmente para su aplicación de Azure Functions (véase WorkerOptions). Este serializador es System.Text.Json por defecto en lugar de Newtonsoft.Json. Los cambios en WorkerOptions.Serializer se aplican de manera transitiva a Durable Functions.

Para obtener más información sobre la compatibilidad integrada con la serialización JSON en .NET, consulte la documentación de información general sobre la serialización y deserialización de JSON en .NET.

C# (InProc)

Lógica de serialización predeterminada

Durable Functions para . NET en proceso usa internamente Json.NET para serializar los datos de orquestación y entidad a JSON. La configuración de Json.NET predeterminada que se usa es la siguiente:

Entradas, salidas y estado:

JsonSerializerSettings
{
    TypeNameHandling = TypeNameHandling.None,
    DateParseHandling = DateParseHandling.None,
}

Excepciones:

JsonSerializerSettings
{
    ContractResolver = new ExceptionResolver(),
    TypeNameHandling = TypeNameHandling.Objects,
    ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
}

Lea la documentación más detallada sobre JsonSerializerSettingsaquí.

Personalización de la serialización con atributos de .NET

Durante la serialización, Json.NET busca varios atributos en las clases y propiedades que controlan cómo se serializan y deserializan los datos desde JSON. Si posee el código fuente del tipo de datos pasado a Durable Functions API, considere la posibilidad de agregar estos atributos al tipo para personalizar la serialización y la deserialización.

Personalizar la serialización con inserción de dependencias

Las aplicaciones de funciones destinadas a .NET y que se ejecutan en el entorno de ejecución de Functions V3 pueden usar Dependency Injection (DI) para personalizar cómo se serializan los datos y las excepciones. En el código de ejemplo siguiente se muestra cómo usar la inserción de dependencias para invalidar los valores de serialización de Json.NET predeterminados mediante implementaciones personalizadas de las interfaces de servicio IMessageSerializerSettingsFactory y IErrorSerializerSettingsFactory.

using Microsoft.Azure.Functions.Extensions.DependencyInjection;
using Microsoft.Azure.WebJobs.Extensions.DurableTask;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;
using System.Collections.Generic;

[assembly: FunctionsStartup(typeof(MyApplication.Startup))]
namespace MyApplication
{
    public class Startup : FunctionsStartup
    {
        public override void Configure(IFunctionsHostBuilder builder)
        {
            builder.Services.AddSingleton<IMessageSerializerSettingsFactory, CustomMessageSerializerSettingsFactory>();
            builder.Services.AddSingleton<IErrorSerializerSettingsFactory, CustomErrorSerializerSettingsFactory>();
        }

        /// <summary>
        /// A factory that provides the serialization for all inputs and outputs for activities and
        /// orchestrations, as well as entity state.
        /// </summary>
        internal class CustomMessageSerializerSettingsFactory : IMessageSerializerSettingsFactory
        {
            public JsonSerializerSettings CreateJsonSerializerSettings()
            {
                // Return your custom JsonSerializerSettings here
            }
        }

        /// <summary>
        /// A factory that provides the serialization for all exceptions thrown by activities
        /// and orchestrations
        /// </summary>
        internal class CustomErrorSerializerSettingsFactory : IErrorSerializerSettingsFactory
        {
            public JsonSerializerSettings CreateJsonSerializerSettings()
            {
                // Return your custom JsonSerializerSettings here
            }
        }
    }
}

JavaScript

Lógica de serialización y deserialización

Las aplicaciones de Azure Functions para Node usan JSON.stringify() para la serialización y JSON.Parse() para la deserialización. La mayoría de los tipos se deberían serializar y deserializar sin problemas. En los casos en los que la lógica predeterminada no es suficiente, definir un toJSON() método en el objeto invalidará la lógica de serialización. Sin embargo, no existe ningún análogo para la deserialización de objetos.

Para la personalización completa de la canalización de serialización o deserialización, considere la posibilidad de controlar la serialización y deserialización con su propio código y pasar los datos como cadenas.

PowerShell

Lógica de serialización y deserialización

Las aplicaciones PowerShell de Durable Functions utilizan el procesamiento predeterminado de JSON en PowerShell para las cargas útiles de orquestación y actividades. En la mayoría de los casos, los objetos compatibles con JSON sencillos se serializan y deserializan correctamente sin configuración adicional.

Si necesitas un comportamiento personalizado para una forma de carga útil, serializa o deserializa los datos tú mismo dentro de tus funciones y pasa los valores compatibles con JSON resultantes entre orquestadores, actividades y entidades. Este enfoque mantiene el formato de datos explícito y evita depender de una API de personalización del serializador que no está expuesta para PowerShell.

Para escenarios más complejos, considera representar tus datos como cadenas simples, arrays o tablas hash y convertir entre formatos dentro de tu código de función.

Python

Lógica de serialización y deserialización

Se recomienda usar anotaciones de tipo para asegurarse de que Durable Functions serialice y deserialice los datos correctamente. Aunque muchos tipos integrados se controlan automáticamente, algunos tipos de datos integrados requieren anotaciones de tipo para conservar el tipo durante la deserialización.

Para los tipos de datos personalizados, puede hacer posible la serialización y deserialización de JSON definiendo los métodos de clase to_json y from_json en su clase de tipo de datos. Tenga en cuenta que no se llama a estos métodos en el valor devuelto de la función de orquestador, lo que significa que el valor devuelto debe ser de forma nativa serializable en JSON. Para obtener más información, consulte Enlaces.

Para validar cargas útiles deserializadas frente a un tipo esperado y optar opcionalmente por un modo estricto endurecido, consulte Migrar a serialización segura por tipos en Durable Functions for Python.

Java

Java usa las bibliotecas Jackson v2.x para la serialización y deserialización de cargas de datos. Puede usar anotaciones de Jackson en los tipos POJO para personalizar el comportamiento de serialización.

Pasos siguientes

• Centros de tareas en Durable Functions
• Proveedores de almacenamiento de Durable Functions
• Enlaces para Durable Functions