AWS Lambda触发长时Web端点：C#实现无等待响应的调用方案问询

Perfect, let's solve this problem where you need to trigger a long-running HTTP endpoint from a C# Lambda without waiting for the response—so your Lambda can exit quickly and avoid unnecessary runtime costs. Here's how to do it properly:

Key Principles #

The goal is to ensure the request is successfully dispatched to the endpoint, while letting your Lambda finish execution immediately. We need to avoid two pitfalls:

• Resource leaks: Don't create a new HttpClient on each Lambda invocation.
• Lost requests: Make sure the request isn't stuck in a local queue when the Lambda exits.

Solution 1: Minimal Fire-and-Forget with HttpClient #

This approach uses HttpClient.SendAsync with HttpCompletionOption.ResponseHeadersRead, which tells the client to complete the task as soon as the server sends response headers (not waiting for the full response body). This guarantees the endpoint has received your request before the Lambda moves on.

Code Example #

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Amazon.Lambda.Core;

[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]

namespace FireAndForgetLambda
{
    public class Function
    {
        // Reuse HttpClient across invocations to prevent socket exhaustion
        private readonly HttpClient _httpClient;

        public Function()
        {
            _httpClient = new HttpClient
            {
                // Set a reasonable timeout (we won't wait for it, but it prevents hanging connections)
                Timeout = TimeSpan.FromSeconds(10)
            };
        }

        public async Task<string> FunctionHandler(ILambdaContext context)
        {
            var targetEndpoint = "https://your-long-running-endpoint.example.com";
            
            try
            {
                // Build your request (adjust method, content as needed)
                var request = new HttpRequestMessage(HttpMethod.Post, targetEndpoint)
                {
                    Content = new StringContent(
                        "{\"payload\":\"your-data-here\"}", 
                        Encoding.UTF8, 
                        "application/json")
                };

                // Initiate the request without awaiting it
                // Use ResponseHeadersRead to confirm the server received the request
                _ = _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);

                context.Logger.LogInformation("Successfully initiated fire-and-forget request to the endpoint");
                return "Request dispatched";
            }
            catch (Exception ex)
            {
                // Catch synchronous exceptions (e.g., invalid URL, DNS failure)
                context.Logger.LogError($"Failed to start request: {ex.Message}");
                return "Request initiation failed";
            }
        }
    }
}

Solution 2: Fire-and-Forget with Async Error Logging #

If you want to log any errors that happen after the request is sent (e.g., server errors, network drops mid-request), wrap the call in a Task.Run and handle exceptions inside the background task:

Code Example #

// Inside your FunctionHandler method
try
{
    var request = new HttpRequestMessage(HttpMethod.Post, targetEndpoint)
    {
        Content = new StringContent("{\"payload\":\"your-data-here\"}", Encoding.UTF8, "application/json")
    };

    // Run the request in a background task to capture async exceptions
    _ = Task.Run(async () =>
    {
        try
        {
            await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
        }
        catch (Exception ex)
        {
            // Log errors that occur after the request was initiated
            context.Logger.LogError($"Background request failed: {ex.Message}");
        }
    });

    context.Logger.LogInformation("Fire-and-forget request initiated");
    return "Request dispatched";
}
catch (Exception ex)
{
    context.Logger.LogError($"Failed to start request: {ex.Message}");
    return "Request initiation failed";
}

Critical Notes #

1. Reuse HttpClient: Always initialize HttpClient in the Lambda constructor, not in the handler. Creating a new client every time leads to socket exhaustion, which will break your Lambda over time.
2. ResponseHeadersRead: This is crucial—without it, SendAsync waits for the full response body, which defeats the purpose of fire-and-forget. Using this option ensures the server has accepted your request before the Lambda exits.
3. Exception Handling: Synchronous exceptions (like invalid URLs) will throw immediately, so catch those in the main handler. Async exceptions (like server timeouts) only get caught if you wrap the call in a Task.Run and handle them there.

内容的提问来源于stack exchange，提问作者dr11