Ir al contenido principal
Español— Elegir un idioma
Menú

Límites de la plataforma

Lección 10 de 14 Actualizado el 29 de julio de 2026 Avanzado
En esta página
  1. Conoce los límites
  2. Dos segundos entre cada actividad
  3. Dos megabytes por invocación
  4. El presupuesto de eventos y volumen
  5. Sin E/S en el flujo de trabajo
  6. Puntos clave

Conoce los límites

La plataforma Mistral Workflows se encuentra en Vista Previa Pública (a fecha de abril de 2026). Al igual que cualquier sistema de orquestación, impone restricciones técnicas que debes comprender para diseñar flujos de trabajo robustos. Estos límites no son simples notas al pie de la documentación; se manifiestan en producción, a menudo en etapas avanzadas del desarrollo, como errores de serialización o flujos de trabajo terminados inesperadamente sin ninguna advertencia en tu código. Conocerlos de antemano cambia la forma en que estructuras tu lógica de procesamiento.

La siguiente tabla resume las restricciones clave y la consecuencia concreta de superar cada una.

Limitación Valor Consecuencia si se supera
Retraso entre actividades 2 segundos Latencia inevitable entre cada llamada a actividad
Entrada/salida por invocación 2 MB Error de serialización, el flujo de trabajo falla
Eventos por ejecución 51.200 El flujo de trabajo se termina forzosamente
Tamaño total por ejecución 50 MB El flujo de trabajo se termina forzosamente
Tiempo de espera predeterminado 1 hora Flujo de trabajo cancelado (configurable hasta 7 días)
Tiempo de espera máximo 7 días El flujo de trabajo se cancela automáticamente
E/S en flujos de trabajo Prohibido Error de no determinismo durante la reproducción

Dos segundos entre cada actividad

La plataforma impone un retraso mínimo de 2 segundos entre las llamadas a actividades. Esta latencia no es un problema inicial de maduración; es inherente a la arquitectura de orquestación, que persiste cada evento antes de continuar. Es el precio de la durabilidad.

El impacto es fácil de calcular y a menudo sorprendente. Un flujo de trabajo que encadena diez actividades secuenciales consume al menos veinte segundos de tiempo de orquestación, independientemente de cuánto tarden las actividades en sí mismas. Si cada actividad se ejecuta en cincuenta milisegundos, has diseñado una tarea de medio segundo que tarda veinte segundos en devolver un resultado.

La solución consiste en agrupar operaciones que no necesiten ser independientes en una única actividad. Compara estas dos versiones del mismo pipeline de PNL.

# SUBÓPTIMO: 3 actividades = 6 segundos de latencia de orquestación
@workflows.workflow.define(name="pipeline_lent")
class SlowPipeline:
    @workflows.workflow.entrypoint
    async def run(self, text: str) -> dict:
        tokens = await tokenize(text)
        embeddings = await calculate_embeddings(tokens)
        clusters = await cluster(embeddings)
        return clusters

# OPTIMIZADO: 1 actividad = 2 segundos de latencia de orquestación
@workflows.activity()
async def complete_nlp_processing(text: str) -> dict:
    tokens = tokenize_local(text)
    embeddings = calculate_embeddings_local(tokens)
    clusters = cluster_local(embeddings)
    return {"clusters": clusters}

@workflows.workflow.define(name="pipeline_rapide")
class FastPipeline:
    @workflows.workflow.entrypoint
    async def run(self, text: str) -> dict:
        return await complete_nlp_processing(text)

La regla para dividir se vuelve simple: crea una actividad separada solo si necesitas la garantía de persistencia entre dos operaciones. Si dos operaciones pueden fallar juntas sin causar problemas —como el tokenizado local y el cálculo de incrustaciones encadenados en memoria—, agrúpalas.

Dos megabytes por invocación

Cada llamada a actividad está limitada a 2 MB de entrada y 2 MB de salida, basándose en la representación JSON serializada de los datos. Un informe en PDF, un conjunto de imágenes o una exportación CSV grande superarán fácilmente este límite, provocando que el flujo de trabajo falle con un error de serialización.

La solución se resume en una frase: pasa referencias, nunca cargas útiles. La actividad descarga los datos desde el almacenamiento externo, los procesa localmente (donde está limitada solo por la memoria del worker) y devuelve la URL del resultado.

@workflows.activity()
async def traiter_gros_fichier(fichier_url: str) -> dict:
    """Descargar, procesar y volver a subir el archivo.
    Solo las URLs pasan a través del flujo de trabajo."""
    async with httpx.AsyncClient() as client:
        # Descargar desde S3/GCS
        response = await client.get(fichier_url)
        contenu = response.content  # Podría ser 100 MB

        # Procesar el archivo
        resultat = traiter(contenu)

        # Subir el resultado
        await client.put(
            "https://storage.example.com/résultats/output.json",
            content=resultat
        )

    return {"url_resultat": "https://storage.example.com/résultats/output.json"}

El presupuesto de eventos y volumen

Cada ejecución tiene un límite máximo de 51.200 eventos. La plataforma genera un evento por cada inicio de actividad, cada finalización de actividad, cada señal recibida y cada temporizador activado. En la práctica, una llamada a actividad cuesta entre dos y tres eventos una vez contados los metadatos, situando un flujo de trabajo de cien actividades en torno a 250 o 300 eventos. En otras palabras, el límite permite entre quince y veinte mil llamadas a actividades por ejecución: muy por encima de lo que requieren la mayoría de los casos de uso.

Solo alcanzarás este límite con procesamiento por lotes masivo; por ejemplo, iterando sobre cincuenta mil documentos en una única ejecución. El patrón de continuación, detallado en la siguiente lección, resuelve esto: el flujo de trabajo procesa un lote y luego lanza un nuevo flujo de trabajo para el siguiente lote, reiniciando el contador de eventos.

El segundo límite concerne al volumen: el tamaño acumulado de todos los eventos en una ejecución no debe superar los 50 MB. Esto se llena más rápido si tus actividades devuelven objetos ricos, ya que cada resultado se escribe en el registro. Se aplica el mismo reflejo: devuelve un identificador en lugar de una estructura completa, almacena los resultados intermedios en un servicio externo, pagina el procesamiento en lotes; esto es suficiente en la gran mayoría de los casos.

Sin E/S en el flujo de trabajo

La última línea de la tabla no es un límite de dimensionamiento, sino una regla de diseño, ya cubierta bajo el determinismo. El código del flujo de trabajo no debe contener operaciones de entrada/salida: ni llamadas a red (httpx, aiohttp, requests), ni lectura o escritura de archivos (open, aiofiles), ni acceso a bases de datos, ni lectura de variables de entorno para dirigir bifurcaciones. Todas estas operaciones residen en actividades, cuyos resultados se registran y, por tanto, son reproducibles de forma idéntica.

Puntos clave

  • 2 segundos de latencia mínima entre cada actividad: agrupa operaciones relacionadas
  • 2 MB máximo por entrada/salida de actividad: usa almacenamiento externo para datos grandes
  • 51.200 eventos y 50 MB máximo por ejecución: usa el patrón de continuación para flujos de trabajo muy largos
  • Sin E/S en el código del flujo de trabajo: todo va en actividades
  • Estas limitaciones provienen de la arquitectura subyacente de Temporal y del estado de Vista Previa Pública