如何诊断Azure虚拟机上ASP.NET Web API请求缓慢问题

Great job already ruling out the obvious culprits—low CPU, fast API processing, and unlinked slow EF queries. Let's dig into some less obvious places to track down that 2-5 second delay plaguing your Azure VM-hosted ASP.NET Web API:

1. Dig Into Network Latency (Client ↔ VM ↔ Backends) #

Since your Unity interception shows API processing takes under 15ms, the delay is likely happening outside your API's core logic:

• Client-to-VM latency: Have your team run ping or tracert from the client environment to your Azure VM's public IP. Look for inconsistent round-trip times (RTTs) that spike during slow requests. Azure's regional routing or network peering can sometimes cause unexpected latency blips.
• VM-to-backend latency: If your API wraps external/backend services, test calls directly from the VM using curl or Postman. Measure how long those backend calls take—if they're spiking to 2-5s, that's your issue. Even lightweight wrappers can inherit latency from their dependencies.
• Azure Network Watcher: Use this tool to check your VM's network interface metrics. Look for packet loss, high latency percentiles, or any throttling alerts that line up with slow request times.

2. Audit the ASP.NET Request Pipeline #

Your API processing is fast, but middleware in the pipeline might be adding hidden delays:

• Enable request tracing: For ASP.NET Framework, turn on Failed Request Tracing and configure it to capture requests taking over 1 second. This will give you a step-by-step breakdown of every module's execution time (think authentication, logging, CORS, etc.). For ASP.NET Core, use built-in Activity tracing or tools like OpenTelemetry to map pipeline performance.
• Check for conditional middleware: If certain middleware only runs for API requests (not static content), verify if it's doing heavy work like database lookups or external calls that could be slow.

3. Rule Out Connection Pool Exhaustion #

Slow requests often tie back to waiting for database connections, even when CPU is low:

• Monitor SQL connection counters: Track System.Data.SqlClient metrics like NumberOfActiveConnections, WaitTime for connection requests, and NumberOfPooledConnections. If WaitTime climbs above 100ms during slow API calls, your app is waiting for available connections in the pool.
• Validate connection string settings: Ensure Max Pool Size is set appropriately (default is 100) and that your code properly disposes of connections/EF contexts (use using statements to avoid leaking connections).

4. Check Azure VM-Specific Limits #

Azure VMs have unique constraints that can cause unexpected slowdowns:

• CPU credit throttling: If you're using a B-series VM, check CPU Credits Consumed in Azure Monitor. When credits run out, the VM gets throttled—even if average CPU is low, peak request times might hit this limit.
• Disk performance: Even if disk activity looks low, slow I/O (e.g., using standard HDD instead of Premium SSD) can impact things like session state, cached data, or temporary file writes. Monitor Average Disk Sec/Read and Average Disk Sec/Write—anything over 100ms is a red flag.

5. Test for DNS Resolution Delays #

If your API relies on any external or internal Azure services, slow DNS lookups can add huge latency:

• From your VM, run nslookup for your backend service domains 10+ times. If any lookup takes over 1 second, that's a likely culprit.
• As a quick test, add static entries for critical domains to your VM's hosts file. If slow requests disappear, you'll know DNS is the issue—then you can configure Azure DNS private zones or adjust VM DNS settings to fix it.

6. Diagnose Thread Pool Starvation #

Low CPU doesn't mean your app isn't stuck waiting for threads:

• Track thread pool metrics: Monitor ThreadPool Threads, Queue Length, and Completed Work Items/sec. If the queue length stays high during slow requests, your app is blocking threads (e.g., with synchronous I/O calls) which prevents the thread pool from handling new requests quickly.
• Use PerfView: Run PerfView on the VM during slow request periods to analyze thread pool activity. It can show you exactly which threads are blocked and why.

Start with network latency and connection pool checks—those are the most common hidden causes in scenarios like yours. Let us know what you uncover!

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