基于IIS 7.0的Web API异步并发请求处理及Akka.net实现问询

1. General Implementation Approach (Without Akka.NET) #

Given your constraints—100+ requests, <3s response time, 500ms per backend call—concurrency is non-negotiable. Here’s how to build this in ASP.NET Web API (IIS 7.0):

Key Steps:

• Reusable HttpClient Setup:
  Create a static HttpClient instance (avoid creating one per request to prevent socket exhaustion). Adjust connection limits to handle concurrent calls:

  ServicePointManager.DefaultConnectionLimit = 100; // Match expected concurrent requests
  public static readonly HttpClient BackendClient = new HttpClient { Timeout = TimeSpan.FromSeconds(1) }; // Add timeout to avoid hanging
  

• Parallelize Calls with Async/Await:
  Use Task.WhenAll to execute backend calls concurrently. To avoid overwhelming the backend, use a SemaphoreSlim to throttle parallelism if needed:

  var semaphore = new SemaphoreSlim(initialCount: 20); // Adjust based on backend capacity
  var tasks = requestObjects.Select(async obj => {
      await semaphore.WaitAsync();
      try {
          var response = await BackendClient.PostAsJsonAsync("backend-url", obj);
          response.EnsureSuccessStatusCode();
          return await response.Content.ReadAsAsync<ResultType>();
      } catch (Exception ex) {
          // Handle errors (return failure result, log, etc.)
          return new ResultType { IsSuccess = false, Error = ex.Message };
      } finally {
          semaphore.Release();
      }
  });
  
  var results = await Task.WhenAll(tasks);
  

• Aggregate & Return:
  Combine all results into your response object, including any failure details. Ensure the action is marked async to avoid blocking the IIS thread pool:

  public async Task<IHttpActionResult> Post(List<RequestObject> requests) {
      // ... parallel calls and aggregation ...
      return Ok(aggregatedResponse);
  }
  

• Tune IIS & ASP.NET Settings:
  • In IIS Application Pool: Increase "Maximum Worker Processes" (if using web garden) and "Queue Length".
  • In web.config: Adjust ASP.NET concurrency limits:

    <system.web>
        <httpRuntime maxRequestLength="10240" /> <!-- Allow 10MB requests (adjust as needed) -->
        <applicationPool maxConcurrentRequestsPerCPU="500" maxConcurrentThreadsPerCPU="0" />
    </system.web>
    

• Error & Timeout Handling:
  Set a reasonable timeout on HttpClient (e.g., 1s) to ensure no single call delays the entire response. Handle timeouts and HTTP errors gracefully in each task.

2. Akka.NET Implementation Options #

Yes, Akka.NET is a great fit for this scenario—it excels at managing concurrent, fault-tolerant workloads. Here are two primary approaches:

Option 1: Actor-Based Parallel Processing

Actors provide a natural way to isolate individual backend calls and manage concurrency:

• Parent Actor: Receives the incoming request collection, tracks pending responses, and aggregates results.
• Worker Actors: A pool of actors (created via Props and routers) that handle individual backend calls. Each worker sends the request to the backend, processes the result, and sends it back to the parent.
• Supervision: Use Akka's supervision strategies to handle failed workers (e.g., restart a worker if a backend call fails, or log the error and continue).

Example outline:

// Parent actor
public class RequestAggregatorActor : ReceiveActor {
    private int _pendingCount;
    private List<ResultType> _results = new List<ResultType>();
    private IActorRef _sender;

    public RequestAggregatorActor() {
        Receive<List<RequestObject>>(requests => {
            _sender = Sender;
            _pendingCount = requests.Count;
            // Use a router to distribute to worker pool
            var workerRouter = Context.ActorOf(Props.Create<BackendCallWorkerActor>().WithRouter(new RoundRobinPool(20)));
            foreach (var req in requests) {
                workerRouter.Tell(req);
            }
        });

        Receive<ResultType>(result => {
            _results.Add(result);
            _pendingCount--;
            if (_pendingCount == 0) {
                _sender.Tell(_results);
                Context.Stop(Self);
            }
        });
    }
}

// Worker actor
public class BackendCallWorkerActor : ReceiveActor {
    private readonly HttpClient _client = BackendClient; // Reuse static client

    public BackendCallWorkerActor() {
        Receive<RequestObject>(async req => {
            try {
                var response = await _client.PostAsJsonAsync("backend-url", req);
                response.EnsureSuccessStatusCode();
                var result = await response.Content.ReadAsAsync<ResultType>();
                Sender.Tell(result);
            } catch (Exception ex) {
                Sender.Tell(new ResultType { IsSuccess = false, Error = ex.Message });
            }
            Context.Stop(Self);
        });
    }
}

Option 2: Akka Streams for Stream Processing

Akka Streams simplifies handling concurrent workloads with built-in backpressure:

• Convert the incoming request collection into a stream source.
• Use Flow.MapAsync with a parallelism factor to execute backend calls concurrently.
• Aggregate results using Sink.Fold to build the final response.

Example outline:

var source = Source.From(requestObjects);
var flow = Flow.Create<RequestObject>()
    .MapAsync(parallelism: 20, async req => {
        try {
            var response = await BackendClient.PostAsJsonAsync("backend-url", req);
            response.EnsureSuccessStatusCode();
            return await response.Content.ReadAsAsync<ResultType>();
        } catch (Exception ex) {
            return new ResultType { IsSuccess = false, Error = ex.Message };
        }
    });
var sink = Sink.Fold<List<ResultType>, ResultType>(new List<ResultType>(), (acc, res) => {
    acc.Add(res);
    return acc;
});

var aggregatedResults = await source.Via(flow).RunWith(sink, system);

Akka.NET in IIS Considerations:

• Initialize the Akka.NET Actor System as a singleton on application start (e.g., in Global.asax).
• Handle application pool recycles gracefully—use Akka's persistence if needed, or ensure the actor system is restarted correctly.

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