Hai lỗi HTTP gây tốn thời gian nhất trong một API ASP.NET Core không nằm ở code khó: trả 403 khi người dùng chưa đăng nhập, và trả 200 cho một response đáng lẽ phải là 304. Cả hai đều “chạy đúng” trên máy dev, và cả hai đều làm client xử lý sai.
Bài này là phần nền HTTP và HTTPS cho mọi thứ sau đó trong lộ trình: method nào retry được, status code nào client hiểu, header nào quyết định cache, và TLS bảo vệ được gì — cũng như không bảo vệ được gì.
Mục lục
Cập nhật 2026
- Kestrel hỗ trợ HTTP/3 qua MsQuic. Trên Windows, MsQuic đi kèm; trên Linux cần cài
libmsquic. HTTP/3 chỉ chạy trên TLS, không có biến thểh3c. - TLS 1.3 là mặc định khi cả hai đầu hỗ trợ; handshake 1-RTT và 0-RTT resumption có mặt trên hầu hết trình duyệt hiện đại.
- ASP.NET Core 10 trả
ValidationProblemDetailstự động cho Minimal API khi bậtAddValidation(), mặc định 400 — không phải 422. - Output caching và rate limiting là middleware có sẵn;
AddRateLimitermặc định trả 503, nên đặt rõ429nếu muốn client backoff đúng.
Đọc một giao tiếp HTTP trước khi tin vào framework
Mọi abstraction trong ASP.NET Core — HttpContext, model binding, TypedResults — đều sinh ra cùng một thứ trên dây. Nhìn nó một lần giúp bạn debug phần còn lại nhanh hơn nhiều.
GET /api/products/42 HTTP/1.1
Host: shop.example.com
Accept: application/json
Accept-Encoding: br, gzip
If-None-Match: "p-42-v7"
Authorization: Bearer eyJhbGciOi...
HTTP/1.1 304 Not Modified
Date: Fri, 06 Nov 2026 09:12:03 GMT
ETag: "p-42-v7"
Cache-Control: private, max-age=60
Vary: Accept, Accept-Encoding
Với HTTP/2, dòng request line biến thành các pseudo-header :method, :path, :authority, :scheme; phần còn lại vẫn là cặp header giống hệt. Đó là lý do curl -v trên HTTP/2 in ra cùng thông tin nhưng ở dạng khác.
curl -sv --http2 https://shop.example.com/api/products/42 \
-H "Accept: application/json" \
-H 'If-None-Match: "p-42-v7"'
# Chỉ xem phiên bản giao thức thực tế
curl -s --http2 -o /dev/null -w '%{http_version}\n' https://shop.example.com/
curl -s --http3-only -o /dev/null -w '%{http_version}\n' https://shop.example.com/
Trong code, HttpContext.Request.Method, Path, Headers, Query là các view trên đúng những dòng trên. Không có gì huyền bí ở tầng ASP.NET Core; nếu một header không tới được handler, vấn đề nằm ở proxy, ở Kestrel, hoặc ở việc bạn quên bật forward headers.
Method: an toàn và idempotent không phải chuyện học thuật
Hai thuộc tính này quyết định ai được phép retry request của bạn: trình duyệt, proxy, thư viện HTTP, và chính bạn khi viết resilience handler.
| Method | Safe | Idempotent |
|---|---|---|
| GET, HEAD, OPTIONS | Có | Có |
| PUT, DELETE | Không | Có |
| POST | Không | Không |
| PATCH | Không | Không bắt buộc |
Safe nghĩa là không thay đổi trạng thái tài nguyên; idempotent nghĩa là gửi N lần cho cùng kết quả như gửi một lần. DELETE lần hai trả 404 vẫn là idempotent về mặt trạng thái cuối. POST thì không: retry một POST tạo đơn hàng có thể tạo hai đơn. Đây là lý do các API thanh toán dùng idempotency key trong header hoặc body, chứ không dựa vào method.
PATCH chỉ idempotent nếu bạn thiết kế nó như vậy (ví dụ body là “set status = paid”), còn “tăng quantity thêm 1” thì không. Nếu client cần retry an toàn, thiết kế operation theo hướng thay thế giá trị thay vì cộng dồn.
Status code: 401 khác 403, và những mã hay bị lạm dụng
401 Unauthorized nghĩa là “bạn chưa được xác thực” — thiếu credential, token hết hạn, chữ ký sai. Response bắt buộc có WWW-Authenticate để client biết cách xác thực. 403 Forbidden nghĩa là “đã biết bạn là ai, nhưng bạn không được phép”. Server không nên tiết lộ lý do chi tiết trong 403.
Cái bẫy thường gặp: cookie authentication trong ASP.NET Core mặc định redirect về trang login (302) khi request chưa xác thực. Với API, hãy cấu hình để trả 401 thay vì redirect, hoặc dùng Results.Challenge() với scheme JWT.
| Mã | Dùng khi | Ghi chú |
|---|---|---|
| 400 | Body sai cú pháp, thiếu field | Mặc định của validation trong ASP.NET Core 10 |
| 401 | Chưa xác thực | Cần WWW-Authenticate |
| 403 | Đã xác thực, không có quyền | Không dùng cho “chưa login” |
| 404 | Không tìm thấy | Không dùng để che 403 nếu client cần phân biệt |
| 409 | Xung đột trạng thái | Trùng unique key, optimistic concurrency |
| 412 | Precondition failed | If-Match không khớp ETag |
| 422 | Đúng cú pháp, sai ngữ nghĩa | Chọn một quy ước và giữ nhất quán |
| 429 | Vượt rate limit | Kèm Retry-After |
Về 409 và 422: nhiều team dùng lẫn lộn. Quy ước dễ bảo trì là 409 cho xung đột với trạng thái hiện có (email đã tồn tại, version cũ), 422 cho dữ liệu vượt qua kiểm tra cú pháp nhưng vi phạm quy tắc nghiệp vụ. Quan trọng hơn mã cụ thể là client của bạn có một bảng xử lý cố định, không phải đoán theo từng endpoint.
Đặt rate limiter trả đúng mã:
// File: Program.cs
builder.Services.AddRateLimiter(options =>
{
options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
options.AddFixedWindowLimiter("api", limiter =>
{
limiter.PermitLimit = 100;
limiter.Window = TimeSpan.FromMinutes(1);
limiter.QueueLimit = 0;
});
});
app.UseRateLimiter();
Cache: Cache-Control, ETag và 304
HTTP caching có hai chế độ. Freshness quyết định client dùng lại bản sao mà không hỏi server (max-age). Validation quyết định client hỏi server “bản này còn đúng không” bằng If-None-Match, và server trả 304 với body rỗng.
| Header | Ý nghĩa thực dụng |
|---|---|
Cache-Control: private, max-age=60 |
Chỉ cache trên trình duyệt, 60 giây |
public, s-maxage=300 |
CDN/proxy cache 5 phút |
no-store |
Không lưu ở bất kỳ đâu; dùng cho dữ liệu nhạy cảm |
no-cache |
Được lưu, nhưng phải validate lại mỗi lần |
stale-while-revalidate=30 |
Trả bản cũ trong lúc refresh nền |
ETag là dấu vân tay của representation. Client gửi lại trong If-None-Match; nếu khớp, server trả 304 và tiết kiệm toàn bộ body. ETag mạnh ("abc") yêu cầu byte-for-byte giống nhau; ETag yếu (W/"abc") cho phép khác biệt không đáng kể như encoding.
// File: Endpoints/ProductEndpoints.cs
group.MapGet("/{id:int}", async (int id, HttpContext http, AppDb db) =>
{
var product = await db.Products.AsNoTracking()
.Where(p => p.Id == id)
.Select(p => new ProductDto(p.Id, p.Name, p.Version))
.FirstOrDefaultAsync();
if (product is null) return Results.NotFound();
var etag = new EntityTagHeaderValue($"\"p-{product.Id}-v{product.Version}\"");
http.Response.GetTypedHeaders().ETag = etag;
http.Response.GetTypedHeaders().CacheControl =
new CacheControlHeaderValue { Private = true, MaxAge = TimeSpan.FromSeconds(60) };
var ifNoneMatch = http.Request.GetTypedHeaders().IfNoneMatch;
if (ifNoneMatch.Any(t => t.Tag == etag.Tag && !t.IsWeak))
return Results.StatusCode(StatusCodes.Status304NotModified);
return Results.Ok(product);
});
Hai lưu ý: đặt header trước khi ghi body, và luôn thêm Vary khi response phụ thuộc vào Accept, Accept-Encoding hoặc Authorization. Thiếu Vary: Accept-Encoding là lỗi kinh điển khiến CDN trả bản gzip cho client không nhận gzip.
Với response đọc nhiều, output caching ở server rẻ hơn nhiều so với việc tính lại:
builder.Services.AddOutputCache(options =>
{
options.AddBasePolicy(p => p.Expire(TimeSpan.FromSeconds(30)));
});
app.UseOutputCache();
group.MapGet("/catalog", GetCatalog)
.CacheOutput(p => p.SetVaryByQuery("page").Expire(TimeSpan.FromSeconds(30)));
Không cache response có Authorization mà không có policy riêng. Output cache mặc định không phân biệt người dùng, nên một endpoint trả dữ liệu theo tenant rất dễ rò rỉ dữ liệu giữa các tenant nếu bạn quên SetVaryByHeader("Authorization") hoặc một key riêng.
Content negotiation: client nói nó muốn gì
Accept liệt kê media type kèm q-value; server chọn representation tốt nhất hoặc trả 406. Trong ASP.NET Core, TypedResults.Json luôn trả JSON bất kể Accept, còn Results.Ok đi qua content negotiator và có thể trả XML nếu bạn đăng ký formatter XML. Đây là khác biệt thực dụng: API JSON thuần nên dùng TypedResults.Json để tránh bất ngờ.
builder.Services.AddControllers()
.AddXmlSerializerFormatters(); // chỉ thêm khi thật sự cần XML
group.MapGet("/products/{id:int}", GetProduct)
.Produces<ProductDto>(StatusCodes.Status200OK)
.ProducesProblem(StatusCodes.Status404NotFound);
Produces không chỉ là metadata cho OpenAPI 3.1; nó cũng là hợp đồng bạn tự kiểm tra khi review. Nếu endpoint khai báo chỉ trả JSON mà client gửi Accept: application/xml, hành vi đúng là 406 — và bạn nên viết test cho trường hợp đó.
HTTP/1.1, HTTP/2 và HTTP/3: khác nhau ở đâu
HTTP/1.1 xử lý tuần tự trên mỗi connection. Browser mở nhiều connection song song để bù, kèm theo chi phí TLS cho từng connection. HTTP/2 dùng framing nhị phân, nhiều stream trên một connection TCP, nén header bằng HPACK. Multiplexing giải quyết head-of-line blocking ở tầng ứng dụng, nhưng vẫn còn HOL ở tầng TCP: một packet mất là tất cả stream trên connection đó chờ.
HTTP/3 chuyển sang QUIC trên UDP. Mỗi stream độc lập ở tầng transport, nên mất packet chỉ ảnh hưởng stream đó. QUIC tích hợp TLS 1.3 trong handshake, hỗ trợ 0-RTT cho connection đã gặp, và connection migration khi IP đổi (hữu ích cho mobile). Cái giá: UDP 443 bị chặn ở một số mạng doanh nghiệp, nên client cần fallback — thực tế là qua Alt-Svc hoặc bản ghi HTTPS trong DNS.
// File: Program.cs
builder.WebHost.ConfigureKestrel(options =>
{
options.ListenAnyIP(8080, listen =>
{
listen.Protocols = HttpProtocols.Http1AndHttp2;
});
options.ListenAnyIP(8443, listen =>
{
listen.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
listen.UseHttps();
});
});
Đừng kỳ vọng HTTP/2 hay HTTP/3 sửa được vấn đề N+1 query hay payload quá lớn. Chúng cải thiện chi phí trên dây; chi phí phía server vẫn nguyên.
TLS 1.3 và những gì HTTPS thật sự che
Handshake TLS 1.3 gọn hơn 1.2: client gửi ClientHello kèm key_share, server trả ServerHello với key share của mình, chứng chỉ và Finished — thường 1-RTT trước khi dữ liệu đầu tiên đi. Trong TLS 1.3, chứng chỉ được mã hóa, và mọi cipher suite đều có forward secrecy (không còn trao đổi khóa RSA tĩnh).
Điểm cần chính xác: HTTPS mã hóa method, path, query string, header và body. Nó không che tên miền: SNI trong ClientHello vẫn là plaintext trừ khi dùng ECH, địa chỉ IP đích vẫn lộ, và DNS query trước đó cũng vậy nếu không dùng DoH/DoT. Kẻ quan sát vẫn thấy bạn kết nối tới shop.example.com, thấy kích thước và nhịp của traffic — chỉ không thấy nội dung. Vì vậy HTTPS không chống được traffic analysis, và cũng không làm URL trở nên “vô hình”.
0-RTT chỉ nên dùng cho request idempotent: early data có thể bị replay bởi kẻ chặn đường truyền, nên đừng bật cho POST thanh toán.
HSTS là cách buộc browser không quay lại HTTP:
if (!app.Environment.IsDevelopment())
{
app.UseHsts();
}
app.UseHttpsRedirection();
UseHsts gửi Strict-Transport-Security: max-age=2592000; includeSubDomains (mặc định 30 ngày). Chỉ bật ở production qua HTTPS thật: nếu bật trên domain còn endpoint HTTP nội bộ, bạn tự khóa mình. UseHttpsRedirection trả 307 mặc định — đúng cho POST vì giữ nguyên method và body.
Cookie và CORS: hai thứ hay bị cấu hình sai
Cookie phiên cần ba thuộc tính: Secure, HttpOnly, SameSite. Mặc định của trình duyệt hiện đại là SameSite=Lax khi server không gửi thuộc tính; SameSite=None bắt buộc đi kèm Secure. HttpOnly chặn JavaScript đọc cookie, giảm thiệt hại khi có XSS nhưng không thay thế việc chống XSS. Tiền tố __Host- ràng buộc cookie vào origin, không cho Domain và bắt buộc Secure + Path=/.
builder.Services.AddAntiforgery();
builder.Services.Configure<CookiePolicyOptions>(options =>
{
options.MinimumSameSitePolicy = SameSiteMode.Lax;
options.Secure = CookieSecurePolicy.Always;
options.HttpOnly = HttpOnlyPolicy.Always;
});
CORS thì khác: nó là cơ chế trình duyệt áp đặt, không phải server bảo vệ endpoint. Với request “không đơn giản” (method khác GET/HEAD/POST, hoặc content type application/json), browser gửi preflight OPTIONS kèm Access-Control-Request-Method và Access-Control-Request-Headers. Server trả Access-Control-Allow-Origin, Allow-Methods, Allow-Headers, và có thể Max-Age để cache preflight.
builder.Services.AddCors(options =>
{
options.AddPolicy("spa", policy => policy
.WithOrigins("https://app.example.com")
.AllowAnyHeader()
.AllowAnyMethod()
.AllowCredentials());
});
app.UseCors("spa");
Khi AllowCredentials() được bật, AllowAnyOrigin() không hợp lệ — browser sẽ từ chối * cùng credential. Và CORS không thay thế authorization: một origin được phép gọi API vẫn phải vượt qua kiểm tra quyền ở server.
HTTP và HTTPS: khác nhau ở đâu
| Điểm | HTTP | HTTPS |
|---|---|---|
| Lớp bảo vệ | Không có; dữ liệu đọc được trên đường truyền | TLS 1.3: mã hóa, xác thực, toàn vẹn |
| Cổng mặc định | 80 | 443 |
| Việc bạn phải làm | Không dùng cho traffic thật | Chứng chỉ, HSTS, redirect, kiểm tra cipher |
Không có lý do chính đáng để phục vụ traffic người dùng qua HTTP trong năm 2026. Ngoại lệ duy nhất là mạng nội bộ đã được kiểm soát, và ngay cả khi đó, việc thêm TLS thường rẻ hơn chi phí điều tra một sự cố.
Sai lầm thường gặp
- Trả 200 với body rỗng thay vì 204 hoặc 404. Client không phân biệt được “không có gì” và “không tìm thấy”.
- Dùng 500 cho lỗi validation. Lỗi phía client phải là 4xx, nếu không alerting của bạn sẽ nhiễu và client không biết sửa gì.
- Bật HSTS khi chưa có HTTPS ở mọi subdomain. Hậu quả kéo dài bằng
max-age. - Cấu hình CORS bằng
AllowAnyOrigin().AllowCredentials(). Cấu hình này bị từ chối, hoặc middleware ném lỗi lúc chạy. - Tin rằng HTTPS ẩn được URL khỏi log/proxy. Path được mã hóa trên dây, nhưng server, reverse proxy và APM vẫn ghi lại đầy đủ.
Checklist
- API trả 401 kèm
WWW-Authenticate, không redirect; 403 chỉ khi đã xác thực. - Mọi endpoint đọc có
Cache-ControlvàETag; test 304 bằngcurlvớiIf-None-Match. - Rate limiter trả 429 kèm
Retry-After. - Cookie có
Secure,HttpOnly,SameSite; không dùngSameSite=NonethiếuSecure. - Bật HSTS + HTTPS redirection ở production, kiểm tra bằng
curl -I. - Chạy
curl --http2và--http3-onlyđể xác nhận giao thức thực tế trước khi tối ưu tiếp.
Đi tiếp: Xây dựng RESTful API hiệu quả với ASP.NET Core áp dụng trực tiếp các quy ước status code ở trên. Khi cần hiệu năng ở tầng transport cho service-to-service, bài gRPC trong ASP.NET Core giải thích vì sao HTTP/2 là điều kiện bắt buộc. Và ASP.NET Core Roadmap giữ thứ tự các chặng.



