Algunos workflwos requieren de input por parte de una persona u otro sistema cuando el proceso automatizado termina. Las Durable Functions pueden suspender una orchestration mientras espera por un external event, y entonces recomenzar desde su durable state cuando ese event llega.
La orchestration suspendida no mantiene un worker ni una invocacion de funcion activa. Esto se recomienda para approval windows de horas a dias.
Model an approval as an external event
Un external event es un one-way message, con nombre, enviado a una instancia especifica de orquestacion. El orchestrator crea una durable task con wait_for_external_event() y cede esa task cuando necesita del event data.
Las Durable Functions extensions persisten un evento que llega al orchestrator antes de que este comience la espera, para que el workflow pueda consumir ese buffered event más tarde.
Para un document-processing workflow, una activity primero crea un approval record y notifica al adjuster asignado. El orchestrator entonces espera a un evento ApprovalResponse que contiene la decision y la identidad del reviewer.
Diseña el event contract alrededor de workflow decisions, en vez de una user-interface action. Un approval payload compacto puede contener:
- Decision Un valor fijo como
ApprovedoRejected - Reviewer ID para auditar y correlacionar
- Document ID el work item que el reviewer ha evaluado
- Approval version Un valor que ayuda al workflow a rechazar una respuesta para una review request viaje
- Comment reference URL para cargar detalles, almacenado fuera del flujo
Combina un external event con un durable timer
Un approval process necesita una deadline para que un workflow no espere de manera infinita.
Usa context.create_timer() con context.current_utc_datetime. NO USAR time.sleep() u otras APIs bloqueantes. Un durable timer graba el deadline en la orchestration history y no requiere que el worker se mantenga activo mientras no hay trabajo.
Patrón human interaction - es una carrera entre el event task contra el timer task con context.task_any(). Si el evento gana, el orchestrator lee el event result y cancela el timer. Si el timer gana, el orchestrator sigue el timeout path.
ejemplo que implementa approval, rejection y timeout outcomes. Usa un input estable y orchestration-safe time para el replay
# Code fragment - focus on the event-and-timer race
from datetime import timedelta
import azure.durable_functions as df
def orchestrator(
context: df.DurableOrchestrationContext,
):
review_request = context.get_input()
yield context.call_activity("notify_approver", review_request)
approval_task = context.wait_for_external_event("ApprovalResponse")
deadline = context.current_utc_datetime + timedelta(hours=24)
timeout_task = context.create_timer(deadline)
winner = yield context.task_any([approval_task, timeout_task])
if winner == approval_task:
if not timeout_task.is_completed:
timeout_task.cancel()
response = approval_task.result
if response["decision"] == "Approved":
return {"status": "Approved"}
return {"status": "Rejected"}
return {"status": "TimedOut"}
Una external event task no requiere cancelación después de que el timer gane. Si el workflow puede recibir otro evento con el mismo nombre despues, definimos si la app ignora ese evento tardia, lo graba para auditarlo, o lo enruta hacia orta orchestration instance nueva.
Send an event to the correct instance
Una client function usa las Durable Functions orchestration client binding para enviar un evento. El cliente debe conocer el orchestration instance ID o usar el mismo event name que el orchestrator espera. Los event names deberian ser estables.
fragmento que muestra Durable Function call tras un OK de app-specific auth y validacion. El endpoint devuelve 202 ya que el event delivery retoma la orchestration de manera asincrona
# Code fragment - focus on raising an external event
import json
import azure.functions as func
import azure.durable_functions as df
app = df.DFApp(http_auth_level=func.AuthLevel.FUNCTION)
@app.route(route="approvals/{instance_id}", methods=["POST"])
@app.durable_client_input(client_name="client")
async def submit_approval(
req: func.HttpRequest,
client: df.DurableOrchestrationClient,
) -> func.HttpResponse:
instance_id = req.route_params["instance_id"]
response = req.get_json()
reviewer = authorize_reviewer(req)
validated_event = validate_approval_response(response, reviewer)
await client.raise_event(
instance_id,
"ApprovalResponse",
validated_event,
)
return func.HttpResponse(
json.dumps({"status": "Accepted"}),
status_code=202,
mimetype="application/json",
)
Handle duplicate and out-of-order responses
Diferentes servicios pueden mandar la misma decision mas de una vez. External events tienen at-least-once delivery guarantee, por lo que restarts, escalado o fallos pueden producir deliveries duplicadas. Sigue siendo nuestra responsabilidad garantizar idempotencia ya que un evento duplicado no debería crear un segundo approval record o repetir una operación downstream.
Podemos incluir un ID estable para approvals y que una actividad de manera atómica compruebe este ID para reportar si la operación ya existe.
Respuestas out-of-order requieren de una policy explicita. Evitar usar solo el orden de llegada cuando hay múltiples sistemas que pueden mandar eventos.
Choose a timeout outcome
Un timeout es un outcome pero no necesariamente un fallo técnico. El orchestrator debe elegir un terminal path y hacer schedule de cualquier update requerida, a través de activities.