azure-functions

Azure Functions patterns — isolated worker model, Durable Functions orchestration, cold-start optimization, production hardening across .NET, Python, and Node.js. USE WHEN building, orchestrating, or optimizing Azure Functions apps (durable workflows, triggers/bindings, cold starts).

Zur Installation springen

Repository: Sheshiyer/skill-clusters
Letzte Quellaktivität: 5. Juni 2026 um 17:21
Erkannte Sprache von SKILL.md: Englisch
Sterne: 0
Forks: 1

Installationsoptionen

Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.

Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.

Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.

npx skills add https://github.com/Sheshiyer/skill-clusters --skill azure-functions

Der Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.

Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.

Quelldateien prüfen

Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.

SKILL.md

Quellanweisungen · Schreibgeschützte Vorschau

Zurück zur Suche Zurück zur Installation

arcplume

Arcplume runs Grok through the Grok Build CLI's own OAuth-authenticated session (grok login) for image generation, with strict preflight validation, secret-safe handling, and headless CLI-driven execution -- no separate XAI_API_KEY billing. Video falls back to the billed xAI API. USE WHEN a user wants to generate an image via a locally logged-in Grok Build CLI session, e.g. 'generate an image with grok', 'use grok build', or 'use my logged-in grok session'.

2026-07-07

selemene-core

Shared reference for the Selemene cluster: the two report surfaces (deterministic Rust reports vs. narrative witness-pipeline readings), the @selemene/bridge CLI contract, the output manifest format, and non-prescriptive witnessing tone. USE WHEN deciding which Selemene surface to invoke or when routing between birth/compatibility/transit reports and solo/dyadic readings.

2026-07-07

selemene-orchestrator

Route Selemene Engine tasks to the right surface: deterministic reports (birth/compatibility/transit) via selemene-core and the @selemene/bridge CLI, or narrative witness readings via selemene-report. USE WHEN the user wants anything under the Selemene/Noesis umbrella but has not named the exact surface.

2026-07-07

Alle aus diesem Repository ansehen

    // Add HttpClientFactory (prevents socket exhaustion)
    services.AddHttpClient();

    // Add your services
    services.AddSingleton<IMyService, MyService>();
})
.Build();

public HttpTriggerFunction(
    ILogger<HttpTriggerFunction> logger,
    IMyService service)
{
    _logger = logger;
    _service = service;
}

[Function("HttpTrigger")]
public async Task<HttpResponseData> Run(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req)
{
    _logger.LogInformation("Processing request");

    try
    {
        var result = await _service.ProcessAsync(req);

        var response = req.CreateResponse(HttpStatusCode.OK);
        await response.WriteAsJsonAsync(result);
        return response;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error processing request");
        var response = req.CreateResponse(HttpStatusCode.InternalServerError);
        await response.WriteAsJsonAsync(new { error = "Internal server error" });
        return response;
    }
}

return {
  status: 200,
  jsonBody: { message: `Hello, ${name}!` }
};

try:
    name = req.params.get("name")
    if not name:
        try:
            req_body = req.get_json()
            name = req_body.get("name")
        except ValueError:
            pass

    if name:
        return func.HttpResponse(
            json.dumps({"message": f"Hello, {name}!"}),
            mimetype="application/json"
        )
    else:
        return func.HttpResponse(
            json.dumps({"message": "Hello, World!"}),
            mimetype="application/json"
        )
except Exception as e:
    logging.error(f"Error processing request: {str(e)}")
    return func.HttpResponse(
        json.dumps({"error": "Internal server error"}),
        status_code=500,
        mimetype="application/json"
    )

    // Functions execute sequentially, state persisted between each
    var validated = await context.CallActivityAsync<ValidatedOrder>(
        "ValidateOrder", order);

    var payment = await context.CallActivityAsync<PaymentResult>(
        "ProcessPayment", validated);

    var shipped = await context.CallActivityAsync<ShippingResult>(
        "ShipOrder", new ShipRequest { Order = validated, Payment = payment });

    var notification = await context.CallActivityAsync<bool>(
        "SendNotification", shipped);

    return new OrderResult
    {
        OrderId = order.Id,
        Status = "Completed",
        TrackingNumber = shipped.TrackingNumber
    };
}

[Function("ValidateOrder")]
public static async Task<ValidatedOrder> ValidateOrder(
    [ActivityTrigger] Order order, FunctionContext context)
{
    var logger = context.GetLogger<OrderWorkflow>();
    logger.LogInformation("Validating order {OrderId}", order.Id);

    // Validation logic...
    return new ValidatedOrder { /* ... */ };
}

[Function("ProcessPayment")]
public static async Task<PaymentResult> ProcessPayment(
    [ActivityTrigger] ValidatedOrder order, FunctionContext context)
{
    // Payment processing with built-in retry...
    return new PaymentResult { /* ... */ };
}

[Function("OrderWorkflow_HttpStart")]
public static async Task<HttpResponseData> HttpStart(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
    [DurableClient] DurableTaskClient client,
    FunctionContext context)
{
    var order = await req.ReadFromJsonAsync<Order>();
    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
        "OrderOrchestrator", order);

    return client.CreateCheckStatusResponse(req, instanceId);
}

    // Fan-out: Start all tasks in parallel
    var tasks = images.Select(image =>
        context.CallActivityAsync<ImageResult>("ProcessImage", image));

    // Fan-in: Wait for all tasks to complete
    var results = await Task.WhenAll(tasks);

    // Aggregate results
    var successful = results.Count(r => r.Success);
    var failed = results.Count(r => !r.Success);

    return new ProcessingResult
    {
        TotalProcessed = results.Length,
        Successful = successful,
        Failed = failed,
        Results = results.ToList()
    };
}

[Function("ProcessImage")]
public static async Task<ImageResult> ProcessImage(
    [ActivityTrigger] string imageUrl, FunctionContext context)
{
    var logger = context.GetLogger<ParallelProcessing>();
    logger.LogInformation("Processing image: {Url}", imageUrl);

    try
    {
        // Image processing logic...
        await Task.Delay(1000); // Simulated work

        return new ImageResult
        {
            Url = imageUrl,
            Success = true,
            ProcessedUrl = $"processed-{imageUrl}"
        };
    }
    catch (Exception ex)
    {
        logger.LogError(ex, "Failed to process {Url}", imageUrl);
        return new ImageResult { Url = imageUrl, Success = false };
    }
}

// Python equivalent
// @app.orchestration_trigger(context_name="context")
// def process_images_orchestrator(context: df.DurableOrchestrationContext):
//     images = context.get_input()
//
//     # Fan-out: Create parallel tasks
//     tasks = [context.call_activity("ProcessImage", img) for img in images]
//
//     # Fan-in: Wait for all
//     results = yield context.task_all(tasks)
//
//     return {"processed": len(results), "results": results}

// Pre-initialize expensive resources
// Database connections, HttpClients, etc.

    // Singleton for expensive initialization
    services.AddSingleton<IExpensiveService>(sp =>
    {
        // Initialize once, reuse across invocations
        return new ExpensiveService();
    });
}

public QueueProcessor(ILogger<QueueProcessor> logger, IMyService service)
{
    _logger = logger;
    _service = service;
}

[Function("ProcessQueueMessage")]
public async Task Run(
    [QueueTrigger("myqueue-items", Connection = "AzureWebJobsStorage")]
    QueueMessage message)
{
    _logger.LogInformation("Processing message: {Id}", message.MessageId);

    try
    {
        var payload = JsonSerializer.Deserialize<MyPayload>(message.Body);
        await _service.ProcessAsync(payload);

        _logger.LogInformation("Message processed successfully: {Id}", message.MessageId);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error processing message: {Id}", message.MessageId);

        // Message will be retried up to maxDequeueCount (default 5)
        // Then moved to poison queue: myqueue-items-poison
        throw;
    }
}

// Optional: Monitor poison queue
[Function("ProcessPoisonQueue")]
public async Task ProcessPoison(
    [QueueTrigger("myqueue-items-poison", Connection = "AzureWebJobsStorage")]
    QueueMessage message)
{
    _logger.LogWarning("Processing poison message: {Id}", message.MessageId);

    // Log to monitoring, alert, or store for manual review
    await _service.HandlePoisonMessageAsync(message);
}

// Start orchestration (returns immediately)
string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
    "LongRunningOrchestrator", input);

// Return status URLs for polling
return client.CreateCheckStatusResponse(req, instanceId);

// Queue the work, return immediately
var workItem = new WorkItem
{
    Id = workId,
    Request = input
};

// Return work ID for status checking
var response = req.CreateResponse(HttpStatusCode.Accepted);
await response.WriteAsJsonAsync(new
{
    workId = workId,
    statusUrl = $"/api/status/{workId}"
});

return workItem;

[Function("StartLongProcess")]
public static async Task<HttpResponseData> Start(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
    [DurableClient] DurableTaskClient client)
{
    var input = await req.ReadFromJsonAsync<WorkRequest>();

    // Start orchestration, returns immediately
    string instanceId = await client.ScheduleNewOrchestrationInstanceAsync(
        "LongRunningOrchestrator", input);

    // Returns status URLs for polling
    return client.CreateCheckStatusResponse(req, instanceId);
}

// Client polls statusQueryGetUri until complete

[Function("StartWork")]
public static async Task<HttpResponseData> StartWork(
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req,
    [QueueOutput("work-queue")] out WorkItem workItem)
{
    var workId = Guid.NewGuid().ToString();

    workItem = new WorkItem { Id = workId, /* ... */ };

    var response = req.CreateResponse(HttpStatusCode.Accepted);
    await response.WriteAsJsonAsync(new {
        id = workId,
        statusUrl = $"/api/status/{workId}"
    });
    return response;
}

// Client provides callback URL
// Function queues work, returns 202 Accepted
// When done, POST result to callback URL

// Program.cs
var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        services.AddHttpClient<IMyApiClient, MyApiClient>(client =>
        {
            client.BaseAddress = new Uri("https://api.example.com");
            client.Timeout = TimeSpan.FromSeconds(30);
        });
    })
    .Build();

// MyApiClient.cs
public class MyApiClient : IMyApiClient
{
    private readonly HttpClient _client;

    public MyApiClient(HttpClient client)
    {
        _client = client;  // Injected, managed by factory
    }

    public async Task<string> GetDataAsync()
    {
        return await _client.GetStringAsync("/data");
    }
}

public static class MyFunction
{
    // Static HttpClient, reused across invocations
    private static readonly HttpClient _httpClient = new HttpClient
    {
        Timeout = TimeSpan.FromSeconds(30)
    };

    [Function("MyFunction")]
    public static async Task Run(...)
    {
        var result = await _httpClient.GetAsync("...");
    }
}

// Also applies to:
// - BlobServiceClient
// - CosmosClient
// - ServiceBusClient
// Use DI or static instances

// BAD - blocks thread
var result = httpClient.GetAsync(url).Result;
someTask.Wait();
Thread.Sleep(5000);

// GOOD - yields thread
var result = await httpClient.GetAsync(url);
await someTask;
await Task.Delay(5000);

// BAD - sync over async
public void ProcessData()
{
    var data = GetDataAsync().Result;  // Blocks!
}

// GOOD - async all the way
public async Task ProcessDataAsync()
{
    var data = await GetDataAsync();
}

// If you must call async from sync context
public static void Main(string[] args)
{
    // Use GetAwaiter().GetResult() at entry point only
    MainAsync(args).GetAwaiter().GetResult();
}

private static async Task MainAsync(string[] args)
{
    // Async code here
}

// host.json
{
  "version": "2.0",
  "functionTimeout": "00:10:00"  // Max for Consumption
}

// Premium plan - 30 min default, unbounded available
{
  "version": "2.0",
  "functionTimeout": "00:30:00"  // Or remove for unbounded
}

[Function("LongWorkflowOrchestrator")]
public static async Task<string> RunOrchestrator(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    // Each activity has its own timeout
    // Workflow can run for days
    await context.CallActivityAsync("Step1", input);
    await context.CallActivityAsync("Step2", input);
    await context.CallActivityAsync("Step3", input);
    return "Complete";
}

// Queue-based chunking
[Function("ProcessChunk")]
[QueueOutput("work-queue")]
public static IEnumerable<WorkChunk> ProcessChunk(
    [QueueTrigger("work-queue")] WorkChunk chunk)
{
    var results = Process(chunk);

    // Queue next chunks if more work
    if (chunk.HasMore)
    {
        yield return chunk.Next();
    }
}

# Create new isolated worker project
func init MyFunctionApp --worker-runtime dotnet-isolated

# Or with .NET 8
dotnet new func --name MyFunctionApp --framework net8.0

// OLD - In-process (FunctionName attribute)
public class InProcessFunction
{
    [FunctionName("MyFunction")]
    public async Task<IActionResult> Run(
        [HttpTrigger] HttpRequest req,
        ILogger log)
    {
        log.LogInformation("Processing");
        return new OkResult();
    }
}

// NEW - Isolated worker (Function attribute)
public class IsolatedFunction
{
    private readonly ILogger<IsolatedFunction> _logger;

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

    [Function("MyFunction")]
    public async Task<HttpResponseData> Run(
        [HttpTrigger(AuthorizationLevel.Function, "get")]
        HttpRequestData req)
    {
        _logger.LogInformation("Processing");
        return req.CreateResponse(HttpStatusCode.OK);
    }
}

// Program.cs
var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults()
    .ConfigureServices(services =>
    {
        // Add App Insights telemetry
        services.AddApplicationInsightsTelemetryWorkerService();
        services.ConfigureFunctionsApplicationInsights();
    })
    .Build();

// host.json
{
  "version": "2.0",
  "logging": {
    "applicationInsights": {
      "samplingSettings": {
        "isEnabled": true,
        "excludedTypes": "Request"
      }
    },
    "logLevel": {
      "default": "Information",
      "Host.Results": "Error",
      "Function": "Information",
      "Host.Aggregator": "Trace"
    }
  }
}

[Function("MyFunction")]
public async Task Run(
    [HttpTrigger] HttpRequestData req,
    FunctionContext context)
{
    // This logger always works
    var logger = context.GetLogger<MyFunction>();
    logger.LogInformation("Processing request");
}

{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "APPLICATIONINSIGHTS_CONNECTION_STRING": "InstrumentationKey=..."
  }
}

// host.json - Extension bundles handle most cases
{
  "version": "2.0",
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

<!-- .csproj - Isolated worker packages -->
<PackageReference Include="Microsoft.Azure.Functions.Worker" Version="1.20.0" />
<PackageReference Include="Microsoft.Azure.Functions.Worker.Sdk" Version="1.16.0" />

<!-- Storage triggers/bindings -->
<PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.Storage" Version="6.2.0" />

<!-- Service Bus -->
<PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.ServiceBus" Version="5.14.0" />

<!-- Cosmos DB -->
<PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.CosmosDB" Version="4.6.0" />

<!-- Durable Functions -->
<PackageReference Include="Microsoft.Azure.Functions.Worker.Extensions.DurableTask" Version="1.1.0" />

# Check registered functions
func host start --verbose

# Look for:
# "Found the following functions:"
# If empty, check extensions and attributes

[Function("Warmup")]
public void Warmup(
    [WarmupTrigger] object warmupContext,
    FunctionContext context)
{
    var logger = context.GetLogger("Warmup");
    logger.LogInformation("Warmup trigger fired");

    // Initialize expensive resources
    _cosmosClient.GetContainer("db", "container");
    _httpClient.GetAsync("https://api.example.com/health").Wait();
}

# Increase pre-warmed instances (costs more)
az functionapp config set \
  --name <app-name> \
  --resource-group <rg> \
  --prewarmed-instance-count 3

// Lazy initialize heavy resources
private static readonly Lazy<ExpensiveClient> _client =
    new Lazy<ExpensiveClient>(() => new ExpensiveClient());

// Connection pooling
services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer(connectionString, sql =>
        sql.MinPoolSize(5)));

# Instances always running, no cold start
az functionapp config set \
  --name <app-name> \
  --resource-group <rg> \
  --minimum-elastic-instance-count 2

name	azure-functions
description	Azure Functions patterns — isolated worker model, Durable Functions orchestration, cold-start optimization, production hardening across .NET, Python, and Node.js. USE WHEN building, orchestrating, or optimizing Azure Functions apps (durable workflows, triggers/bindings, cold starts).
cluster	devops-infra
version	1.0.0
origin	antigravity-awesome-skills (MIT)
risk	none
source	vibeship-spawner-skills (Apache 2.0)
date_added	"2026-02-27T00:00:00.000Z"

name	azure-functions
description	Azure Functions patterns — isolated worker model, Durable Functions orchestration, cold-start optimization, production hardening across .NET, Python, and Node.js. USE WHEN building, orchestrating, or optimizing Azure Functions apps (durable workflows, triggers/bindings, cold starts).
cluster	devops-infra
version	1.0.0
origin	antigravity-awesome-skills (MIT)
risk	none
source	vibeship-spawner-skills (Apache 2.0)
date_added	"2026-02-27T00:00:00.000Z"

azure-functions

Quellinformationen

Installationsoptionen

Quelldateien prüfen

Mehr aus diesem Repository

Mehr aus diesem Repository

Azure Functions

Azure Functions

Patterns

Isolated Worker Model (.NET)

Template

Notes

Node.js v4 Programming Model

Template

Notes

Python v2 Programming Model

Template

function_app.py

Notes

Durable Functions - Function Chaining

Template

Notes

Durable Functions - Fan-Out/Fan-In

Template

Notes

Cold Start Optimization

Template

Notes

Queue Trigger with Error Handling

Template

Notes

HTTP Trigger with Long-Running Pattern

Template

Notes

Sharp Edges

HTTP Timeout is 230 Seconds Regardless of Plan

Use async pattern with Durable Functions

Use queue-based async pattern

Use webhook callback pattern

Socket Exhaustion from HttpClient Instantiation

Use IHttpClientFactory (Recommended)

Use static client (Alternative)

Same pattern for Azure SDK clients

Blocking Async Calls Cause Thread Starvation

Always use async/await

Fix synchronous method calls

Configure async in console/startup

Consumption Plan 10-Minute Timeout Limit

Configure maximum timeout (Consumption)

Upgrade to Premium plan for longer timeouts

Use Durable Functions for long workflows

Break work into smaller chunks

.NET In-Process Model Deprecated November 2026

Use isolated worker for new projects

Migrate existing in-process to isolated

Key migration changes

ILogger Not Outputting to Console or AppInsights

Configure Application Insights properly

Configure logging levels

Use context.GetLogger for reliability

Local development - check local.settings.json

Missing Extension Packages Cause Silent Failures

Check extension bundle (most common)

Install explicit packages for isolated worker

Verify function registration

Premium Plan Still Has Cold Start on New Instances

Add warmup trigger to initialize your code

Configure pre-warmed instance count

Optimize application initialization

Use always-ready instances (most expensive)

Validation Checks

Hardcoded Connection String

Hardcoded API Key in Code

Anonymous Authorization Level in Production

Blocking .Result Call

Blocking .Wait() Call

Thread.Sleep Usage

New HttpClient Instance

HttpClient in Using Statement

In-Process FunctionName Attribute