Patrón de monitoreo

• Complete el artículo de inicio rápido.
• Clona o descarga el proyecto de muestras desde GitHub
  • Muestras de modelos aisladas
  • Ejemplos de modelos en proceso

• Complete el artículo de inicio rápido.
• Clonación o descarga del proyecto de ejemplos de GitHub

• Complete el artículo de inicio rápido.
• Clonación o descarga del proyecto de ejemplos de GitHub

Los ejemplos de PowerShell para Durable Functions aún no están disponibles para este escenario.

Ejemplos de Java para Durable Functions aún no están disponibles para este escenario. Consulte la tabla dinámica de SDK de Durable Task.

• SDK de .NET 8.0 o posterior
• Acceso al Planificador de Tareas Durables de Azure o al emulador local

• Node.js 22 o posterior
• Acceso al Planificador de Tareas Durables de Azure o al emulador local

• Python 3.9 o posterior
• Acceso al Planificador de Tareas Durables de Azure o al emulador local

Este ejemplo se muestra para .NET, JavaScript, Java y Python.

• Java 11 o posterior
• Acceso al Planificador de Tareas Durables de Azure o al emulador local

En este ejemplo se supervisan las condiciones meteorológicas actuales de una ubicación y alerta al usuario por SMS cuando el cielo está despejado. Puede utilizar una función regular desencadenada por temporizador para comprobar el tiempo y enviar alertas. Sin embargo, un problema con este enfoque es la gestión del ciclo de vida. Si solo se debe enviar una sola alerta, el monitor necesita desactivarse después de que se detecte un clima despejado.

En este ejemplo se supervisan las condiciones meteorológicas actuales de una ubicación y alerta al usuario por SMS cuando el cielo está despejado. Puede utilizar una función regular desencadenada por temporizador para comprobar el tiempo y enviar alertas. Sin embargo, un problema con este enfoque es la gestión del ciclo de vida. Si solo se debe enviar una sola alerta, el monitor necesita desactivarse después de que se detecte un clima despejado.

En este ejemplo se supervisa el recuento de problemas en un repositorio de GitHub y se alerta al usuario si hay más de 3 problemas abiertos. Puede usar una función desencadenada por temporizador normal para solicitar los recuentos de problemas abiertos a intervalos regulares. Sin embargo, un problema con este enfoque es la gestión del ciclo de vida. Si solo se debe enviar una alerta, el monitor debe deshabilitarse después de detectar 3 o más problemas.

Los ejemplos de PowerShell para Durable Functions aún no están disponibles para este escenario.

Ejemplos de Java para Durable Functions aún no están disponibles para este escenario. Consulte la tabla dinámica de SDK de Durable Task.

Configuración de la integración de Twilio

En este ejemplo se usa el servicio Twilio para enviar mensajes SMS a un teléfono móvil. Azure Functions ya tiene compatibilidad con Twilio a través del enlace Twilio y el ejemplo usa esa característica.

Lo primero que necesita es una cuenta de Twilio. Puede crear una gratis en https://www.twilio.com/try-twilio. Cuando tenga una cuenta, agregue las tres configuraciones de app a su aplicación de funciones.

Configuración de una API meteorológica

Los ejemplos de C#/JavaScript llaman a una API meteorológica para comprobar las condiciones actuales. Debe proporcionar su propia clave de API meteorológica y actualizar el código de ejemplo en consecuencia. El código de ejemplo hace referencia a una WeatherUndergroundApiKey configuración de la app: sustituye esta clave por la del proveedor meteorológico que elijas.

Configuración de la integración de Twilio

En este ejemplo se usa el servicio Twilio para enviar mensajes SMS a un teléfono móvil. Azure Functions ya tiene compatibilidad con Twilio a través del enlace Twilio y el ejemplo usa esa característica.

Lo primero que necesita es una cuenta de Twilio. Puede crear una gratis en https://www.twilio.com/try-twilio. Cuando tenga una cuenta, agregue las tres configuraciones de app a su aplicación de funciones.

Configuración de una API meteorológica

Los ejemplos de C#/JavaScript llaman a una API meteorológica para comprobar las condiciones actuales. Debe proporcionar su propia clave de API meteorológica y actualizar el código de ejemplo en consecuencia. El código de ejemplo hace referencia a una WeatherUndergroundApiKey configuración de la app: sustituye esta clave por la del proveedor meteorológico que elijas.

Configuración de la integración de Twilio

En este ejemplo se usa el servicio Twilio para enviar mensajes SMS a un teléfono móvil. Azure Functions ya tiene compatibilidad con Twilio a través del enlace Twilio y el ejemplo usa esa característica.

Lo primero que necesita es una cuenta de Twilio. Puede crear una gratis en https://www.twilio.com/try-twilio. Cuando tenga una cuenta, agregue las tres configuraciones de app a su aplicación de funciones.

Los ejemplos de PowerShell para Durable Functions aún no están disponibles para este escenario.

Ejemplos de Java para Durable Functions aún no están disponibles para este escenario. Consulte la tabla dinámica de SDK de Durable Task.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;

namespace VSSample;

public static partial class Monitor
{
    [Function("E3_Monitor")]
    public static async Task Run(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        MonitorRequest input = context.GetInput<MonitorRequest>()
            ?? throw new ArgumentNullException(nameof(context), "An input object is required.");
        VerifyRequest(input);

        ILogger logger = context.CreateReplaySafeLogger("E3_Monitor");
        DateTime endTime = context.CurrentUtcDateTime.AddHours(6);
        logger.LogInformation(
            "Instantiating monitor for {Location}. Expires: {EndTime}.",
            input.Location,
            endTime);

        while (context.CurrentUtcDateTime < endTime)
        {
            logger.LogInformation(
                "Checking current weather conditions for {Location} at {CurrentTime}.",
                input.Location,
                context.CurrentUtcDateTime);

            bool isClear = await context.CallActivityAsync<bool>(
                "E3_GetIsClear",
                input.Location);

            if (isClear)
            {
                await context.CallActivityAsync(
                    "E3_SendGoodWeatherAlert",
                    input.Phone);
                break;
            }

            DateTime nextCheckpoint = context.CurrentUtcDateTime.AddMinutes(30);
            await context.CreateTimer(nextCheckpoint, CancellationToken.None);
        }

        logger.LogInformation("Monitor expiring.");
    }

    private static void VerifyRequest(MonitorRequest request)
    {
        ArgumentNullException.ThrowIfNull(request.Location);
        ArgumentException.ThrowIfNullOrEmpty(request.Phone);
    }
}

public sealed class MonitorRequest
{
    public required Location Location { get; init; }

    public required string Phone { get; init; }
}

public sealed class Location
{
    public required string State { get; init; }

    public required string City { get; init; }

    public override string ToString() => $"{City}, {State}";
}

[FunctionName("E3_Monitor")]
public static async Task Run([OrchestrationTrigger] IDurableOrchestrationContext monitorContext, ILogger log)
{
    MonitorRequest input = monitorContext.GetInput<MonitorRequest>();
    if (!monitorContext.IsReplaying) { log.LogInformation($"Received monitor request. Location: {input?.Location}. Phone: {input?.Phone}."); }

    VerifyRequest(input);

    DateTime endTime = monitorContext.CurrentUtcDateTime.AddHours(6);
    if (!monitorContext.IsReplaying) { log.LogInformation($"Instantiating monitor for {input.Location}. Expires: {endTime}."); }

    while (monitorContext.CurrentUtcDateTime < endTime)
    {
        // Check the weather
        if (!monitorContext.IsReplaying) { log.LogInformation($"Checking current weather conditions for {input.Location} at {monitorContext.CurrentUtcDateTime}."); }

        bool isClear = await monitorContext.CallActivityAsync<bool>("E3_GetIsClear", input.Location);

        if (isClear)
        {
            // It's not raining! Or snowing. Or misting. Tell our user to take advantage of it.
            if (!monitorContext.IsReplaying) { log.LogInformation($"Detected clear weather for {input.Location}. Notifying {input.Phone}."); }

            await monitorContext.CallActivityAsync("E3_SendGoodWeatherAlert", input.Phone);
            break;
        }
        else
        {
            // Wait for the next checkpoint
            var nextCheckpoint = monitorContext.CurrentUtcDateTime.AddMinutes(30);
            if (!monitorContext.IsReplaying) { log.LogInformation($"Next check for {input.Location} at {nextCheckpoint}."); }

            await monitorContext.CreateTimer(nextCheckpoint, CancellationToken.None);
        }
    }

    log.LogInformation($"Monitor expiring.");
}

[Deterministic]
private static void VerifyRequest(MonitorRequest request)
{
    if (request == null)
    {
        throw new ArgumentNullException(nameof(request), "An input object is required.");
    }

    if (request.Location == null)
    {
        throw new ArgumentNullException(nameof(request.Location), "A location input is required.");
    }

    if (string.IsNullOrEmpty(request.Phone))
    {
        throw new ArgumentNullException(nameof(request.Phone), "A phone number input is required.");
    }
}

La función del orquestador requiere una ubicación para supervisar y un número de teléfono al que enviar un mensaje cuando el tiempo aparece despejado en la ubicación. Pase estos datos a la función de orquestador como un objeto MonitorRequest fuertemente tipado.

La función E3_Monitor usa el function.json estándar para las funciones de orquestador.

{
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Este es el código que implementa la función:

const df = require("durable-functions");
const moment = require("moment");

module.exports = df.orchestrator(function* (context) {
    const input = context.df.getInput();
    context.log(
        "Received monitor request. location: " +
            (input ? input.location : undefined) +
            ". phone: " +
            (input ? input.phone : undefined) +
            "."
    );

    verifyRequest(input);

    const endTime = moment.utc(context.df.currentUtcDateTime).add(6, "h");
    context.log(
        "Instantiating monitor for " +
            input.location.city +
            ", " +
            input.location.state +
            ". Expires: " +
            endTime +
            "."
    );

    while (moment.utc(context.df.currentUtcDateTime).isBefore(endTime)) {
        // Check the weather
        context.log(
            "Checking current weather conditions for " +
                input.location.city +
                ", " +
                input.location.state +
                " at " +
                context.df.currentUtcDateTime +
                "."
        );
        const isClear = yield context.df.callActivity("E3_GetIsClear", input.location);

        if (isClear) {
            // It's not raining! Or snowing. Or misting. Tell our user to take advantage of it.
            context.log(
                "Detected clear weather for " +
                    input.location.city +
                    ", " +
                    input.location.state +
                    ". Notifying " +
                    input.phone +
                    "."
            );

            yield context.df.callActivity("E3_SendGoodWeatherAlert", input.phone);
            break;
        } else {
            // Wait for the next checkpoint
            const nextCheckpoint = moment.utc(context.df.currentUtcDateTime).add(30, "s");
            context.log(
                "Next check for " +
                    input.location.city +
                    ", " +
                    input.location.state +
                    " at " +
                    nextCheckpoint.toString()
            );

            yield context.df.createTimer(nextCheckpoint.toDate()); // accomodate cancellation tokens
        }
    }

    context.log("Monitor expiring.");
});

function verifyRequest(request) {
    if (!request) {
        throw new Error("An input object is required.");
    }
    if (!request.location) {
        throw new Error("A location input is required.");
    }
    if (!request.phone) {
        throw new Error("A phone number input is required.");
    }
}

La función E3_Monitor usa el function.json estándar para las funciones de orquestador.

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "context",
      "type": "orchestrationTrigger",
      "direction": "in"
    }
  ]
}

Este es el código que implementa la función:

import azure.durable_functions as df
from datetime import timedelta
from typing import Dict

def orchestrator_function(context: df.DurableOrchestrationContext):

    monitoring_request: Dict[str, str] = context.get_input()
    repo_url: str = monitoring_request["repo"]
    phone: str = monitoring_request["phone"]

    # Expiration of the repo monitoring
    expiry_time = context.current_utc_datetime + timedelta(minutes=5)
    while context.current_utc_datetime < expiry_time:
        # Count the number of issues in the repo (the GitHub API caps at 30 issues per page)
        too_many_issues = yield context.call_activity("E3_TooManyOpenIssues", repo_url)

        # If we detect too many issues, we text the provided phone number
        if too_many_issues:
            # Extract URLs of GitHub issues, and return them
            yield context.call_activity("E3_SendAlert", phone)
            break
        else:

            # Reporting the number of statuses found
            status = f"The repository does not have too many issues, for now ..."
            context.set_custom_status(status)
        
            # Schedule a new "wake up" signal
            next_check = context.current_utc_datetime + timedelta(minutes=1)
            yield context.create_timer(next_check)

    return "Monitor completed!"

main = df.Orchestrator.create(orchestrator_function)

La función de orquestador comprueba periódicamente una condición y envía una alerta si se cumple. Utiliza un temporizador duradero para los intervalos de sondeo y continúa hasta que el monitor expira.

param($Context)

$input = $Context.Input | ConvertFrom-Json
$expirationTime = (Get-Date).AddHours(6)
$pollingInterval = New-TimeSpan -Seconds $input.pollingIntervalSeconds

while ((Get-Date) -lt $expirationTime) {
    # Check current conditions
    $isClear = Invoke-DurableActivity -FunctionName 'E3_GetIsClear' -Input $input.location

    if ($isClear) {
        # Condition met - send alert and exit
        Invoke-DurableActivity -FunctionName 'E3_SendGoodWeatherAlert' -Input $input.phone
        break
    }

    # Wait for the next polling interval
    Start-DurableTimer -Duration $pollingInterval
}

@FunctionName("E3_Monitor")
public void monitorOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    MonitorRequest input = ctx.getInput(MonitorRequest.class);
    Instant expirationTime = ctx.getCurrentInstant().plus(Duration.ofHours(6));
    int pollingInterval = input.getPollingIntervalSeconds();

    while (ctx.getCurrentInstant().isBefore(expirationTime)) {
        // Check current conditions
        boolean isClear = ctx.callActivity(
            "E3_GetIsClear", input.getLocation(), boolean.class).await();

        if (isClear) {
            // Condition met - send alert and exit
            ctx.callActivity("E3_SendGoodWeatherAlert", input.getPhone()).await();
            break;
        }

        // Wait for the next polling interval
        Instant nextCheck = ctx.getCurrentInstant().plus(
            Duration.ofSeconds(pollingInterval));
        ctx.createTimer(nextCheck).await();
    }
}

using Microsoft.DurableTask;
using System;
using System.Threading.Tasks;

[DurableTask(nameof(MonitoringJobOrchestration))]
public class MonitoringJobOrchestration : TaskOrchestrator<JobMonitorInput, JobMonitorResult>
{
    public override async Task<JobMonitorResult> RunAsync(
        TaskOrchestrationContext context, JobMonitorInput input)
    {
        var jobId = input.JobId;
        var pollingInterval = TimeSpan.FromSeconds(input.PollingIntervalSeconds);
        var expirationTime = context.CurrentUtcDateTime.AddSeconds(input.TimeoutSeconds);

        // Initialize monitoring state
        int checkCount = 0;

        while (context.CurrentUtcDateTime < expirationTime)
        {
            // Check current job status
            var jobStatus = await context.CallActivityAsync<JobStatus>(
                nameof(CheckJobStatusActivity),
                new CheckJobInput { JobId = jobId, CheckCount = checkCount });

            checkCount = jobStatus.CheckCount;

            // Make job status available via custom status
            context.SetCustomStatus(jobStatus);

            if (jobStatus.Status == "Completed")
            {
                return new JobMonitorResult
                {
                    JobId = jobId,
                    FinalStatus = "Completed",
                    ChecksPerformed = checkCount
                };
            }

            // Calculate next check time
            var nextCheck = context.CurrentUtcDateTime.Add(pollingInterval);
            if (nextCheck > expirationTime)
            {
                nextCheck = expirationTime;
            }

            // Wait until next polling interval
            await context.CreateTimer(nextCheck, default);
        }

        // Timeout reached
        return new JobMonitorResult
        {
            JobId = jobId,
            FinalStatus = "Timeout",
            ChecksPerformed = checkCount
        };
    }
}

import {
  OrchestrationContext,
  TOrchestrator,
} from "@microsoft/durabletask-js";

const monitorOrchestrator: TOrchestrator = async function* (
  ctx: OrchestrationContext,
  input: { jobId: string; pollingIntervalSeconds: number; timeoutSeconds: number }
): any {
  const { jobId, pollingIntervalSeconds, timeoutSeconds } = input;
  const expirationTime = new Date(
    ctx.currentUtcDateTime.getTime() + timeoutSeconds * 1000
  );

  let checkCount = 0;

  while (ctx.currentUtcDateTime < expirationTime) {
    // Check current job status
    const jobStatus: any = yield ctx.callActivity(checkJobStatus, {
      jobId,
      checkCount,
    });

    checkCount = jobStatus.checkCount;

    // Make job status available via custom status
    ctx.setCustomStatus(jobStatus);

    if (jobStatus.status === "Completed") {
      return {
        jobId,
        finalStatus: "Completed",
        checksPerformed: checkCount,
      };
    }

    // Wait for next polling interval
    yield ctx.createTimer(pollingIntervalSeconds);
  }

  // Timeout reached
  return {
    jobId,
    finalStatus: "Timeout",
    checksPerformed: checkCount,
  };
};

import datetime
from durabletask import task

def monitoring_job_orchestrator(ctx: task.OrchestrationContext, job_data: dict) -> dict:
    """
    Orchestrator that demonstrates the monitoring pattern.

    Periodically checks the status of a job until it completes or times out.
    """
    job_id = job_data.get("job_id")
    polling_interval = job_data.get("polling_interval_seconds", 5)
    timeout = job_data.get("timeout_seconds", 30)

    # Record the start time
    start_time = ctx.current_utc_datetime
    expiration_time = start_time + datetime.timedelta(seconds=timeout)

    # Initialize monitoring state
    job_status = {
        "job_id": job_id,
        "status": "Unknown",
        "check_count": 0
    }

    # Loop until the job completes or times out
    while True:
        # Check current job status
        check_input = {"job_id": job_id, "check_count": job_status.get("check_count", 0)}
        job_status = yield ctx.call_activity("check_job_status", input=check_input)

        # Make the job status available via custom status
        ctx.set_custom_status(job_status)

        if job_status["status"] == "Completed":
            break

        # Check if we've hit the timeout
        current_time = ctx.current_utc_datetime
        if current_time >= expiration_time:
            job_status["status"] = "Timeout"
            break

        # Calculate next check time
        next_check_time = current_time + datetime.timedelta(seconds=polling_interval)
        if next_check_time > expiration_time:
            next_check_time = expiration_time

        # Wait until next polling interval
        yield ctx.create_timer(next_check_time)

    # Return the final status
    return {
        "job_id": job_id,
        "final_status": job_status["status"],
        "checks_performed": job_status["check_count"]
    }

Este ejemplo se muestra para .NET, JavaScript, Java y Python.

import com.microsoft.durabletask.*;
import com.microsoft.durabletask.azuremanaged.DurableTaskSchedulerWorkerExtensions;
import java.time.Duration;

DurableTaskGrpcWorker worker = DurableTaskSchedulerWorkerExtensions.createWorkerBuilder(connectionString)
    .addOrchestration(new TaskOrchestrationFactory() {
        @Override
        public String getName() { return "MonitoringJobOrchestrator"; }

        @Override
        public TaskOrchestration create() {
            return ctx -> {
                JobData jobData = ctx.getInput(JobData.class);
                int pollingCount = 0;

                // Set initial status
                ctx.setCustomStatus(new JobStatus("Starting monitoring..."));

                while (true) {
                    // Update status
                    ctx.setCustomStatus(new JobStatus(
                        "Polling job status (attempt " + (++pollingCount) + ")"));

                    // Wait for polling interval
                    ctx.createTimer(Duration.ofSeconds(jobData.pollingIntervalSeconds)).await();

                    // Check if job is complete (simulated after 3 attempts)
                    if (pollingCount >= 3) {
                        ctx.setCustomStatus(new JobStatus("Job completed successfully"));
                        ctx.complete(new JobResult(
                            "COMPLETED",
                            "Job completed after " + pollingCount + " attempts"));
                        break;
                    }
                }
            };
        }
    })
    .build();

La función E3_GetIsClear obtiene las condiciones meteorológicas actuales usando la API Weather Underground y determina si el cielo está despejado.

using Microsoft.Azure.Functions.Worker;

namespace VSSample;

public static partial class Monitor
{
    [Function("E3_GetIsClear")]
    public static async Task<bool> GetIsClear([ActivityTrigger] Location location)
    {
        WeatherCondition currentConditions =
            await WeatherUnderground.GetCurrentConditionsAsync(location);
        return currentConditions == WeatherCondition.Clear;
    }
}

[FunctionName("E3_GetIsClear")]
public static async Task<bool> GetIsClear([ActivityTrigger] Location location)
{
    var currentConditions = await WeatherUnderground.GetCurrentConditionsAsync(location);
    return currentConditions.Equals(WeatherCondition.Clear);
}

function.json se define como sigue:

{
  "bindings": [
    {
      "name": "location",
      "type": "activityTrigger",
      "direction": "in"
    }
  ],
  "disabled": false
}

Esta es la implementación.

const request = require("request");

const clearWeatherConditions = [
    "Overcast",
    "Clear",
    "Partly Cloudy",
    "Mostly Cloudy",
    "Scattered Clouds",
];

module.exports = function (context, location) {
    getCurrentConditions(location)
        .then(function (data) {
            const isClear = clearWeatherConditions.includes(data.weather);
            context.done(null, isClear);
        })
        .catch(function (err) {
            context.log(`E3_GetIsClear encountered an error: ${err}`);
            context.done(err);
        });
};

function getCurrentConditions(location) {
    return new Promise(function (resolve, reject) {
        const options = {
            url: `https://api.wunderground.com/api/${process.env["WeatherUndergroundApiKey"]}/conditions/q/${location.state}/${location.city}.json`,
            method: "GET",
            json: true,
        };
        request(options, function (err, res, body) {
            if (err) {
                reject(err);
            }
            if (body.error) {
                reject(body.error);
            }
            if (body.response.error) {
                reject(body.response.error);
            }
            resolve(body.current_observation);
        });
    });
}

La función E3_TooManyOpenIssues obtiene una lista de problemas abiertos actualmente en el repositorio y determina si hay "demasiados": más de 3 según la muestra.

function.json se define como sigue:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "repoID",
      "type": "activityTrigger",
      "direction": "in"
    }
  ]
}

Esta es la implementación.

import requests
import json

def main(repoID: str) -> str:

    # We use the GitHub API to count the number of open issues in the repo provided
    # Note that the GitHub API only displays at most 30 issues per response, so
    # the maximum number this activity will return is 30. That's enough for demo'ing purposes.
    [user, repo] = repoID.split("/")
    url = f"https://api.github.com/repos/{user}/{repo}/issues?state=open"
    res = requests.get(url)
    if res.status_code != 200:
        error_message = f"Could not find repo {user} under {repo}! API endpoint hit was: {url}"
        raise Exception(error_message)
    issues = json.loads(res.text)
    too_many_issues: bool = len(issues) >= 3
    return too_many_issues

La función E3_GetIsClear comprueba si se cumple la condición. En este ejemplo, comprueba las condiciones meteorológicas de una ubicación.

param($location)

# Call weather API to check current conditions
# In a real app, call an external API here
$conditions = Get-WeatherConditions -Location $location
$conditions -eq 'Clear'

La función E3_GetIsClear comprueba las condiciones meteorológicas actuales de una ubicación utilizando una API meteorológica.

@FunctionName("E3_GetIsClear")
public boolean getIsClear(
        @DurableActivityTrigger(name = "location") Location location) {
    // Call weather API to check current conditions
    String conditions = getWeatherConditions(location);
    return conditions.equals("Clear");
}

La función E3_SendGoodWeatherAlert utiliza Twilio para enviar un SMS que notifica al usuario final que es un buen momento para dar un paseo.

using Microsoft.Azure.Functions.Worker;
using Twilio;
using Twilio.Rest.Api.V2010.Account;
using Twilio.Types;

namespace VSSample;

public static partial class Monitor
{
    [Function("E3_SendGoodWeatherAlert")]
    public static async Task SendGoodWeatherAlert(
        [ActivityTrigger] string phoneNumber)
    {
        string accountSid = Environment.GetEnvironmentVariable("TwilioAccountSid")
            ?? throw new InvalidOperationException("TwilioAccountSid is not configured.");
        string authToken = Environment.GetEnvironmentVariable("TwilioAuthToken")
            ?? throw new InvalidOperationException("TwilioAuthToken is not configured.");
        string fromNumber = Environment.GetEnvironmentVariable("TwilioPhoneNumber")
            ?? throw new InvalidOperationException("TwilioPhoneNumber is not configured.");

        TwilioClient.Init(accountSid, authToken);
        await MessageResource.CreateAsync(
            to: new PhoneNumber(phoneNumber),
            from: new PhoneNumber(fromNumber),
            body: "The weather's clear outside! Go take a walk!");
    }
}

    [FunctionName("E3_SendGoodWeatherAlert")]
    public static void SendGoodWeatherAlert(
        [ActivityTrigger] string phoneNumber,
        ILogger log,
        [TwilioSms(AccountSidSetting = "TwilioAccountSid", AuthTokenSetting = "TwilioAuthToken", From = "%TwilioPhoneNumber%")]
            out CreateMessageOptions message)
    {
        message = new CreateMessageOptions(new PhoneNumber(phoneNumber));
        message.Body = $"The weather's clear outside! Go take a walk!";
    }

internal class WeatherUnderground
{
    private static readonly HttpClient httpClient = new HttpClient();
    private static IReadOnlyDictionary<string, WeatherCondition> weatherMapping = new Dictionary<string, WeatherCondition>()
    {
        { "Clear", WeatherCondition.Clear },
        { "Overcast", WeatherCondition.Clear },
        { "Cloudy", WeatherCondition.Clear },
        { "Clouds", WeatherCondition.Clear },
        { "Drizzle", WeatherCondition.Precipitation },
        { "Hail", WeatherCondition.Precipitation },
        { "Ice", WeatherCondition.Precipitation },
        { "Mist", WeatherCondition.Precipitation },
        { "Precipitation", WeatherCondition.Precipitation },
        { "Rain", WeatherCondition.Precipitation },
        { "Showers", WeatherCondition.Precipitation },
        { "Snow", WeatherCondition.Precipitation },
        { "Spray", WeatherCondition.Precipitation },
        { "Squall", WeatherCondition.Precipitation },
        { "Thunderstorm", WeatherCondition.Precipitation },
    };

    internal static async Task<WeatherCondition> GetCurrentConditionsAsync(Location location)
    {
        var apiKey = Environment.GetEnvironmentVariable("WeatherUndergroundApiKey");
        if (string.IsNullOrEmpty(apiKey))
        {
            throw new InvalidOperationException("The WeatherUndergroundApiKey environment variable was not set.");
        }

        var callString = string.Format("http://api.wunderground.com/api/{0}/conditions/q/{1}/{2}.json", apiKey, location.State, location.City);
        var response = await httpClient.GetAsync(callString);
        var conditions = await response.Content.ReadAsAsync<JObject>();

        JToken currentObservation;
        if (!conditions.TryGetValue("current_observation", out currentObservation))
        {
            JToken error = conditions.SelectToken("response.error");

            if (error != null)
            {
                throw new InvalidOperationException($"API returned an error: {error}.");
            }
            else
            {
                throw new ArgumentException("Could not find weather for this location. Try being more specific.");
            }
        }

        return MapToWeatherCondition((string)(currentObservation as JObject).GetValue("weather"));
    }

    private static WeatherCondition MapToWeatherCondition(string weather)
    {
        foreach (var pair in weatherMapping)
        {
            if (weather.Contains(pair.Key))
            {
                return pair.Value;
            }
        }

        return WeatherCondition.Other;
    }
}

Su function.json es simple:

{
    "bindings": [
      {
        "name": "phoneNumber",
        "type": "activityTrigger",
        "direction": "in"
      },
      {
        "type": "twilioSms",
        "name": "message",
        "from": "%TwilioPhoneNumber%",
        "accountSidSetting": "TwilioAccountSid",
        "authTokenSetting": "TwilioAuthToken",
        "direction": "out"
      }
    ],
    "disabled": false
  }

Y este es el código que envía el mensaje SMS:

module.exports = function (context, phoneNumber) {
    context.bindings.message = {
        body: `The weather's clear outside! Go take a walk!`,
        to: phoneNumber,
    };

    context.done();
};

La función E3_SendAlert usa el enlace de Twilio para enviar un mensaje SMS que notifica al usuario final que hay al menos 3 problemas abiertos en espera de una resolución.

Su function.json es simple:

{
  "scriptFile": "__init__.py",
  "bindings": [
    {
      "name": "repoID",
      "type": "activityTrigger",
      "direction": "in"
    }
  ]
}

Y este es el código que envía el mensaje SMS:

import json
import random

random.seed(10)

def main(phoneNumber: str, message):
  payload = {
    "body": f"Hey! You may want to check on your repo, there are too many open issues",
    "to": phoneNumber
  }

  message.set(json.dumps(payload))
  return "Message sent!"

La función E3_SendGoodWeatherAlert envía una notificación SMS al usuario.

param($phoneNumber)

# Send an SMS alert using your preferred messaging service
Write-Host "Sending good weather alert to $phoneNumber."
# In a real app, use Twilio or another SMS provider here

La función E3_SendGoodWeatherAlert envía una notificación SMS al usuario.

@FunctionName("E3_SendGoodWeatherAlert")
public void sendGoodWeatherAlert(
        @DurableActivityTrigger(name = "phoneNumber") String phoneNumber) {
    // Send an SMS alert using your preferred messaging service
    sendSms(phoneNumber, "The weather is clear outside! Enjoy your day.");
}

using Microsoft.DurableTask;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

[DurableTask(nameof(CheckJobStatusActivity))]
public class CheckJobStatusActivity : TaskActivity<CheckJobInput, JobStatus>
{
    private readonly ILogger<CheckJobStatusActivity> _logger;

    public CheckJobStatusActivity(ILogger<CheckJobStatusActivity> logger)
    {
        _logger = logger;
    }

    public override Task<JobStatus> RunAsync(TaskActivityContext context, CheckJobInput input)
    {
        _logger.LogInformation("Checking status for job: {JobId} (check #{CheckCount})",
            input.JobId, input.CheckCount + 1);

        // Simulate job status - completes after 3 checks
        var status = input.CheckCount >= 3 ? "Completed" : "Running";

        return Task.FromResult(new JobStatus
        {
            JobId = input.JobId,
            Status = status,
            CheckCount = input.CheckCount + 1,
            LastCheckTime = DateTime.UtcNow
        });
    }
}

// Data classes
public class JobMonitorInput
{
    public string JobId { get; set; }
    public int PollingIntervalSeconds { get; set; } = 5;
    public int TimeoutSeconds { get; set; } = 30;
}

public class CheckJobInput
{
    public string JobId { get; set; }
    public int CheckCount { get; set; }
}

public class JobStatus
{
    public string JobId { get; set; }
    public string Status { get; set; }
    public int CheckCount { get; set; }
    public DateTime LastCheckTime { get; set; }
}

public class JobMonitorResult
{
    public string JobId { get; set; }
    public string FinalStatus { get; set; }
    public int ChecksPerformed { get; set; }
}

import { ActivityContext } from "@microsoft/durabletask-js";

const checkJobStatus = async (
  _ctx: ActivityContext,
  input: { jobId: string; checkCount: number }
): Promise<any> => {
  console.log(
    `Checking status for job: ${input.jobId} (check #${input.checkCount + 1})`
  );

  // Simulate job status — completes after 3 checks
  const status = input.checkCount >= 3 ? "Completed" : "Running";

  return {
    jobId: input.jobId,
    status,
    checkCount: input.checkCount + 1,
    lastCheckTime: new Date().toISOString(),
  };
};

import datetime
from durabletask import task

def check_job_status(ctx: task.ActivityContext, job_data: dict) -> dict:
    """
    Activity that checks the status of a long-running job.
    In a real application, this would call an external API or service.
    """
    job_id = job_data.get("job_id", "unknown")
    check_count = job_data.get("check_count", 0)

    # Simulate job status - completes after 3 checks
    if check_count >= 3:
        status = "Completed"
    else:
        status = "Running"

    return {
        "job_id": job_id,
        "status": status,
        "check_count": check_count + 1,
        "last_check_time": datetime.datetime.now().isoformat()
    }

Este ejemplo se muestra para .NET, JavaScript, Java y Python.

En la muestra de Java, el orquestador simula directamente la comprobación de estado. En una aplicación real, crearía una actividad independiente:

.addActivity(new TaskActivityFactory() {
    @Override
    public String getName() { return "CheckJobStatus"; }

    @Override
    public TaskActivity create() {
        return ctx -> {
            JobCheckInput input = ctx.getInput(JobCheckInput.class);

            // Simulate checking job status
            // In a real app, this would call an external API
            String status = input.checkCount >= 3 ? "Completed" : "Running";

            return new JobStatus(status, input.checkCount + 1);
        };
    }
})

Utilizando las funciones activadas por HTTP incluidas en la muestra, puedes iniciar la orquestación enviando la siguiente solicitud HTTP POST:

POST https://{host}/orchestrators/E3_Monitor
Content-Length: 77
Content-Type: application/json

{ "location": { "city": "Redmond", "state": "WA" }, "phone": "+1425XXXXXXX" }

Utilizando las funciones activadas por HTTP incluidas en la muestra, puedes iniciar la orquestación enviando la siguiente solicitud HTTP POST:

POST https://{host}/orchestrators/E3_Monitor
Content-Length: 77
Content-Type: application/json

{ "location": { "city": "Redmond", "state": "WA" }, "phone": "+1425XXXXXXX" }

Necesita una cuenta GitHub. Cree un repositorio público temporal al que pueda abrir incidencias.

Utilizando las funciones activadas por HTTP incluidas en la muestra, puedes iniciar la orquestación enviando la siguiente solicitud HTTP POST:

POST https://{host}/orchestrators/E3_Monitor
Content-Length: 77
Content-Type: application/json

{ "repo": "<your GitHub handle>/<a new GitHub repo under your user>", "phone": "+1425XXXXXXX" }

Por ejemplo, si tu nombre de usuario en GitHub es foo y tu repositorio es bar, establece el valor de "repo" en "foo/bar".

Utilizando la función activada por HTTP incluida en la muestra, puedes iniciar la orquestación enviando la siguiente solicitud HTTP POST:

POST https://{host}/api/orchestrators/E3_Monitor
Content-Type: application/json

{ "location": { "city": "Redmond", "state": "WA" }, "phone": "+1425XXXXXXX" }

Utilizando la función activada por HTTP incluida en la muestra, puedes iniciar la orquestación enviando la siguiente solicitud HTTP POST:

POST https://{host}/api/StartMonitor
Content-Type: application/json

{ "location": { "city": "Redmond", "state": "WA" }, "phone": "+1425XXXXXXX" }

La función de desencadenador HTTP programa la orquestación:

@FunctionName("StartMonitor")
public HttpResponseMessage startMonitor(
        @HttpTrigger(name = "req", methods = {HttpMethod.POST}) HttpRequestMessage<Optional<String>> req,
        @DurableClientInput(name = "durableContext") DurableClientContext durableContext,
        final ExecutionContext context) {
    DurableTaskClient client = durableContext.getClient();
    String instanceId = client.scheduleNewOrchestrationInstance("E3_Monitor", req.getBody().get());
    context.getLogger().info("Started monitor orchestration with ID = " + instanceId);
    return durableContext.createCheckStatusResponse(req, instanceId);
}

using System;
using System.Threading.Tasks;

var client = DurableTaskClientBuilder.UseDurableTaskScheduler(connectionString).Build();

// Schedule the monitoring orchestration
var input = new JobMonitorInput
{
    JobId = "job-" + Guid.NewGuid().ToString(),
    PollingIntervalSeconds = 5,
    TimeoutSeconds = 30
};

string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
    nameof(MonitoringJobOrchestration), input);

Console.WriteLine($"Started monitoring orchestration: {instanceId}");

// Wait for completion while checking status
while (true)
{
    var state = await client.GetInstanceMetadataAsync(instanceId, getInputsAndOutputs: true);

    if (state.RuntimeStatus == OrchestrationRuntimeStatus.Completed ||
        state.RuntimeStatus == OrchestrationRuntimeStatus.Failed)
    {
        Console.WriteLine($"Monitoring completed: {state.ReadOutputAs<JobMonitorResult>().FinalStatus}");
        break;
    }

    Console.WriteLine($"Current status: {state.ReadCustomStatusAs<JobStatus>()?.Status}");
    await Task.Delay(2000);
}

import {
  DurableTaskAzureManagedClientBuilder,
  DurableTaskAzureManagedWorkerBuilder,
} from "@microsoft/durabletask-js-azuremanaged";

const client = new DurableTaskAzureManagedClientBuilder()
  .connectionString(connectionString)
  .build();

const worker = new DurableTaskAzureManagedWorkerBuilder()
  .connectionString(connectionString)
  .addOrchestrator(monitorOrchestrator)
  .addActivity(checkJobStatus)
  .build();

await worker.start();

// Schedule the monitoring orchestration
const input = {
  jobId: `job-${Date.now()}`,
  pollingIntervalSeconds: 5,
  timeoutSeconds: 30,
};

const instanceId = await client.scheduleNewOrchestration(
  monitorOrchestrator,
  input
);

console.log(`Started monitoring orchestration: ${instanceId}`);

// Wait for completion
const result = await client.waitForOrchestrationCompletion(
  instanceId,
  true,
  60
);
console.log(`Final result: ${result?.serializedOutput}`);

await worker.stop();
await client.stop();

from durabletask.azuremanaged.client import DurableTaskSchedulerClient
import time

client = DurableTaskSchedulerClient(
    host_address=endpoint,
    secure_channel=endpoint != "http://localhost:8080",
    taskhub=taskhub,
    token_credential=credential
)

# Schedule the monitoring orchestration
job_data = {
    "job_id": "job-123",
    "polling_interval_seconds": 5,
    "timeout_seconds": 30
}

instance_id = client.schedule_new_orchestration(
    monitoring_job_orchestrator,
    input=job_data
)

print(f"Started monitoring orchestration: {instance_id}")

# Wait for completion
result = client.wait_for_orchestration_completion(instance_id, timeout=60)
print(f"Final result: {result.serialized_output}")

Este ejemplo se muestra para .NET, JavaScript, Java y Python.

import java.time.Duration;
import java.util.UUID;

DurableTaskClient client = DurableTaskSchedulerClientExtensions
    .createClientBuilder(connectionString).build();

// Schedule the monitoring orchestration
JobData jobData = new JobData(
    "job-" + UUID.randomUUID().toString(),
    5,  // polling interval seconds
    30  // timeout seconds
);

String instanceId = client.scheduleNewOrchestrationInstance(
    "MonitoringJobOrchestrator",
    new NewOrchestrationInstanceOptions().setInput(jobData));

System.out.println("Started monitoring orchestration: " + instanceId);

// Wait for completion
OrchestrationMetadata result = client.waitForInstanceCompletion(
    instanceId, Duration.ofSeconds(60), true);

System.out.println("Final result: " + result.readOutputAs(JobResult.class).status);