Frontend, API và blog thường chạy sau một domain; tách mỗi thứ một port hay subdomain thì phải lo CORS, chứng chỉ TLS từng nơi, và mỗi service tự làm rate limit, log, gzip. Bài này dựng một reverse proxy Nginx (1.29.8, trong Docker Compose) route theo path tới ba service và chạy thử từng request để thấy kết quả thật. Đọc xong, bạn tránh được bốn lỗi hay gặp: location khớp nhầm, dấu / trong proxy_pass làm đổi path, header X-Forwarded-* bị giả mạo, và cấu hình mặc định không hợp production.
Nên đọc trước: REST API nâng cao (phần quy ước URL khi route qua API gateway).
1. Reverse proxy là gì, khác gì forward proxy, load balancer, API gateway
Ý chính: reverse proxy đứng phía server và nhận request thay cho các service bên trong. Load balancer và API gateway là reverse proxy chuyên thêm một việc: chia tải, hoặc logic theo API.
- Forward proxy đứng phía client (proxy công ty, VPN); server đích thấy IP của proxy.
- Reverse proxy đứng phía server; client không biết sau nó có bao nhiêu service.
- Load balancer: reverse proxy chia tải giữa nhiều bản sao của cùng một service. Có thể ở tầng 4 (TCP, không đọc HTTP) hoặc tầng 7 (đọc HTTP).
- API gateway: reverse proxy tầng 7 cộng logic theo API: xác thực token, rate limit theo client, quota, biến đổi request, gom response, tài liệu API. Ví dụ Kong, APISIX, Spring Cloud Gateway, AWS API Gateway.
Nginx làm được cả ba vai phía server; ở bài này nó route theo path.
- Kiểm JWT cho đúng (khoá cứng thuật toán,
exp,iss,aud), dù ở gateway hay service: Xác thực: session cookie và JWT. limit_reqtheo IP của Nginx chỉ là một lớp chống DDoS tầng ứng dụng; kết hợp với rate limit theo user hay API key: Tấn công web và OWASP Top 10.
2. Sơ đồ cần dựng
Ý chính: một Nginx đứng trước ba service: /api/ tới backend, /blog/ và /content/ tới blog, còn lại tới frontend.
Bài tập của khoá học vẽ sơ đồ này, mình vẽ lại:
flowchart LR
C[Client] --> P[Nginx :80]
P -- "/ (vd /home)" --> FE[Frontend :8000]
P -- "/api/... (vd /api/orders)" --> BE[Backend :8080]
P -- "/blog/... và /content/..." --> BL[Blog :9000]
| Path client gọi | Đi tới | Path backend nhận |
|---|---|---|
/, /home |
frontend | giữ nguyên |
/api/orders/145 |
backend | giữ nguyên /api/orders/145 |
/blog/posts/1 |
blog | bỏ prefix: /posts/1 |
/content/hot |
blog | giữ nguyên /content/hot |
Blog có hai cách là cố ý (giữ prefix và cắt prefix) để thấy proxy_pass xử lý path thế nào.
3. Lab với Docker Compose
Ý chính: ba service phía sau là Nginx giả lập, trả về JSON ghi path và header chúng nhận được. Nhìn response là biết proxy đã làm gì.
gateway.conf (proxy chính):
upstream backend {
server be:8080;
keepalive 32;
}
server {
listen 80;
server_name _;
client_max_body_size 10m;
# Header chung cho mọi location được proxy
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Request-Id $request_id;
proxy_connect_timeout 2s;
proxy_read_timeout 30s;
location = /healthz {
access_log off;
return 200 "ok\n";
}
# /api/... -> backend, giữ nguyên path (proxy_pass không có phần URI)
location /api/ {
proxy_pass http://backend;
}
# /blog/... -> blog, cắt prefix (proxy_pass có phần URI là "/")
location /blog/ {
proxy_pass http://blog:9000/;
}
# /content/... -> blog, giữ nguyên path
location /content/ {
proxy_pass http://blog:9000;
}
# còn lại -> frontend
location / {
proxy_pass http://fe:8000;
}
}
File lab còn lại: echo.conf, compose.yaml, lệnh chạy và lưu ý Docker Desktop
echo.conf (cho fe, be, blog):
server {
listen 8000;
listen 8080;
listen 9000;
default_type application/json;
location / {
return 200 '{"service":"$hostname","port":"$server_port","uri":"$request_uri","host":"$http_host","xff":"$http_x_forwarded_for","real_ip":"$http_x_real_ip","proto":"$http_x_forwarded_proto"}\n';
}
}
compose.yaml:
services:
gateway:
image: nginx:1.29-alpine
ports: ["8088:80"]
volumes: ["./gateway.conf:/etc/nginx/conf.d/default.conf:ro"]
depends_on: [fe, be, blog]
fe:
image: nginx:1.29-alpine
hostname: fe
volumes: ["./echo.conf:/etc/nginx/conf.d/default.conf:ro"]
be:
image: nginx:1.29-alpine
hostname: be
volumes: ["./echo.conf:/etc/nginx/conf.d/default.conf:ro"]
blog:
image: nginx:1.29-alpine
hostname: blog
volumes: ["./echo.conf:/etc/nginx/conf.d/default.conf:ro"]
Chạy và kiểm tra cấu hình:
docker compose up -d
docker compose exec gateway nginx -t
# nginx: configuration file /etc/nginx/nginx.conf test is successful
curl -s -H 'X-Forwarded-For: 6.6.6.6' http://localhost:8088/api/orders/145
Với Docker Desktop trên Mac, network_mode: host của bài tập gốc không chạy như trên Linux (host ở đây là máy ảo của Docker, không phải máy Mac). Dùng network mặc định của Compose và gọi nhau bằng tên service như trên thì chạy được ở mọi nơi.
Kết quả thật khi chạy (rút gọn):
| Request | Service | uri backend nhận |
Ghi chú |
|---|---|---|---|
/ |
fe | / |
|
/home |
fe | /home |
|
/api/orders/145 |
be | /api/orders/145 |
giữ prefix |
/apiv2 |
fe | /apiv2 |
không khớp /api/, rơi về / |
/blog/posts/1 |
blog | /posts/1 |
prefix bị cắt |
/blog |
(proxy) | 301 → /blog/ |
xem mục 5 |
/content/hot |
blog | /content/hot |
|
/healthz |
(proxy) | ok |
proxy tự trả |
Header backend nhận cho /api/orders/145: host: localhost, xff: 6.6.6.6, 172.22.0.1, real_ip: 172.22.0.1, proto: http. Dòng xff cho thấy proxy nối thêm IP nó thấy vào giá trị client gửi, không thay thế (mục 6).
4. location chọn khối nào
Ý chính: prefix khớp dài nhất thắng, thứ tự viết không quan trọng. Nhưng = khớp chính xác dừng ngay, và regex (xét theo thứ tự file) thắng prefix, trừ khi prefix có ^~.
Nginx chuẩn hoá URI trước (giải mã %XX, xử lý . và .., gộp // thành /), rồi chọn theo thứ tự:
- Duyệt mọi prefix location, nhớ cái có prefix dài nhất khớp.
- Nếu có
location = /pathkhớp chính xác, dừng ngay. - Nếu prefix dài nhất có
^~, dừng, không xét regex. - Xét các regex (
~phân biệt hoa thường,~*không phân biệt) theo thứ tự trong file, regex đầu tiên khớp thắng. - Không regex nào khớp thì dùng prefix đã nhớ ở bước 1.
| Khai báo | Ý nghĩa |
|---|---|
location = /healthz |
chỉ đúng /healthz |
location ^~ /static/ |
prefix, thắng cả regex |
location ~* \.(png|jpg)$ |
regex, xét theo thứ tự |
location /api/ |
prefix thường |
location / |
bắt mọi thứ còn lại |
5. proxy_pass: có hay không có phần URI
Ý chính: proxy_pass không có phần URI (chỉ http://host:port) thì path gửi đi nguyên như client gửi. Có phần URI (dù chỉ là /) thì phần path khớp location bị thay bằng URI đó.
Đây là chỗ sai nhiều nhất. Kết quả thật trên một server thử nghiệm:
| location | proxy_pass | Request | Backend nhận |
|---|---|---|---|
/api/ |
http://backend |
/api/orders |
/api/orders |
/blog/ |
http://blog:9000/ |
/blog/posts/1 |
/posts/1 |
/v1/ |
http://be:8080/internal/ |
/v1/users |
/internal/users |
/api |
http://be:8080/ |
/api/orders |
//orders |
/api |
http://be:8080/ |
/apiv2 |
/v2 |
~ ^/img/(.*)$ |
http://fe:8000/static/$1 |
/img/a.png |
/static/a.png |
Hai dòng /api là lỗi kinh điển: /api bị thay bằng /, nên /orders còn lại thành //orders, còn /apiv2 thành /v2 (nhầm sang API khác).
Request /blog (thiếu / cuối) nhận 301 sang /blog/, và Location mất port 8088. Cách sửa ở khối dưới.
Redirect tự động: vì sao /blog thành 301 mất port, absolute_redirect và proxy_redirect
Kết quả cụ thể: 301 Location: http://localhost/blog/. Nginx tự làm điều này: khi một prefix location kết thúc bằng / và được xử lý bằng proxy_pass, request có URI đúng bằng chuỗi đó nhưng thiếu / được redirect sang bản có /. Port bị mất vì Nginx ghép URL tuyệt đối từ tên server và port nó listen (80), không biết có port mapping bên ngoài.
6. Các header X-Forwarded và chuyện tin ai
Ý chính: qua proxy, backend mất ba thông tin: IP client, domain client gọi (Host), và HTTP hay HTTPS. Nginx mang chúng theo bằng header, nhưng header là thứ client tự gửi được, nên chỉ tin phần do proxy của mình thêm vào.
| Header | Giá trị Nginx đặt | Dùng để |
|---|---|---|
Host |
$host |
backend biết domain gốc (virtual host, dựng URL) |
X-Real-IP |
$remote_addr |
IP của bên kết nối trực tiếp tới proxy |
X-Forwarded-For |
$proxy_add_x_forwarded_for |
chuỗi IP qua từng hop (chặng proxy): giá trị cũ + , + $remote_addr |
X-Forwarded-Proto |
$scheme |
https nếu TLS kết thúc ở proxy |
X-Request-Id |
$request_id |
id ngẫu nhiên để nối log proxy với log backend |
- Không tự đặt thì Nginx gửi
Host: $proxy_host(tên trongproxy_pass) và không cóX-Forwarded-*; đã thử: backend nhậnhost: be:8080,xffrỗng. - Chuẩn mới hơn là
Forwarded(RFC 7239:Forwarded: for=203.0.113.7;proto=https;host=shop.vn), nhưngX-Forwarded-*phổ biến hơn.
Tin X-Forwarded-For tới đâu
Lab gửi X-Forwarded-For: 6.6.6.6, backend nhận 6.6.6.6, 172.22.0.1. Backend lấy phần tử đầu tiên làm IP client (code rất hay viết vậy) thì ai cũng giả được IP: vượt rate limit, giả vị trí, ghi log sai.
Cách đúng: đi từ phải sang trái, bỏ qua IP là proxy của mình; IP đầu tiên không phải proxy của mình là client. Module realip của Nginx làm đúng việc này.
Module realip đã thử: cấu hình và kết quả
set_real_ip_from 172.16.0.0/12; # chỉ tin các proxy trong dải này
real_ip_header X-Forwarded-For;
real_ip_recursive on; # bỏ qua mọi IP tin cậy từ phải sang
| Kết nối tới từ | X-Forwarded-For nhận được |
$remote_addr sau realip |
|---|---|---|
| 127.0.0.1 (không tin) | 6.6.6.6 |
127.0.0.1 (header bị bỏ qua) |
| 172.22.0.2 (tin) | 1.2.3.4, 6.6.6.6 |
6.6.6.6 (bỏ 1.2.3.4 vì nằm bên trái IP không tin đầu tiên) |
Phía Spring Boot
Backend phải đọc các header này thì request.getRemoteAddr(), request.getScheme(), ServletUriComponentsBuilder và redirect mới đúng:
# Tomcat RemoteIpValve đọc X-Forwarded-For / -Proto / -Host / -Port
server.forward-headers-strategy=native
# Chỉ tin IP của proxy/LB thật (regex), mặc định là các dải private
server.tomcat.remoteip.internal-proxies=10\\.0\\.\\d{1,3}\\.\\d{1,3}
- Giá trị
frameworkdùngForwardedHeaderFiltercủa Spring thay cho Tomcat, hợp khi server không phải Tomcat. - Không cấu hình (mặc định
none, trừ khi Spring Boot phát hiện đang chạy trên cloud platform): app sau TLS termination (TLS được giải mã ở proxy) tạo linkhttp://, OAuth2 redirect URI sai, cookieSecurekhông được đặt.
7. Cấu hình cho production
Ý chính: mặc định của Nginx hợp web tĩnh, không hẳn hợp API. Sáu thứ cần xem lại: timeout, keepalive, buffering, retry, kích thước body và DNS của upstream. Log nên có $request_id và $upstream_response_time (chi tiết trong khối WebSocket bên dưới).
| Cấu hình | Mặc định | Vấn đề | Nên làm |
|---|---|---|---|
| Timeout | connect, read, send đều 60s | read tính giữa hai lần đọc, không phải tổng: backend nhỏ giọt một byte mỗi 50 giây giữ kết nối mãi | connect 1–2s, read theo SLA, endpoint chậm cho location riêng |
| Keepalive tới upstream | không có | mỗi request một kết nối TCP mới: hàng chục nghìn socket TIME_WAIT, cạn port |
keepalive N; + proxy_http_version 1.1; + proxy_set_header Connection ""; |
| Buffering | proxy_buffering on |
phá Server-Sent Events và streaming: client nhận cả cục | proxy_buffering off; hoặc backend gửi X-Accel-Buffering: no |
| Retry | proxy_next_upstream error timeout; |
từ 1.9.13 không retry POST, PATCH, LOCK đã gửi, trừ khi bật non_idempotent |
giữ mặc định, giới hạn số lần và thời gian |
| Body | client_max_body_size 1m |
upload 3 MB nhận 413 từ Nginx, log backend trống |
đặt theo location |
| DNS upstream | phân giải một lần lúc đọc cấu hình | 502 khi container được tạo lại với IP mới | xem khối chi tiết dưới |
Chi tiết từng mặc định: timeout, keepalive, buffering, DNS upstream
- Timeout: cả ba là
proxy_connect_timeout,proxy_read_timeout,proxy_send_timeout. Connect để ngắn vì trong data center kết nối chỉ mất vài ms. Endpoint chậm có chủ đích (export, báo cáo) tốt hơn là chuyển sang async job và Idempotency-Key. - Keepalive: hiện tượng
TIME_WAITthấy rõ ở vài nghìn request/giây. Nginx trước 1.29.7 mặc định nói HTTP/1.0 với upstream (đóng kết nối sau mỗi request); từ 1.29.7 mặc định là 1.1, nhưng ghi rõ vẫn tốt cho người đọc cấu hình và cho máy chạy bản cũ. Vì saoTIME_WAITnằm ở bên đóng trước và chỉ làm cạn port ở phía gọi ra có ở Mạng máy tính cho backend. - Buffering: Nginx đọc nhanh response của backend vào buffer (tràn thì ghi file tạm) rồi tự gửi chậm cho client, giải phóng backend sớm. Tốt cho API thường; chỉ tắt ở location streaming.
- Body: upload ảnh nhận
413 Request Entity Too Large; cho upload riêng một location có giới hạn lớn hơn.client_max_body_size(mặc định1m) phải lớn hơn hoặc bằngspring.servlet.multipart.max-file-size/max-request-size, nếu không request bị Nginx trả413trước khi tới Spring. Giới hạn phía Spring và cách lưu file an toàn có ở upload file trong Spring MVC. - DNS: bản open source phân giải tên trong
proxy_pass/upstreamlúc đọc cấu hình, và không khởi động được nếu tên không phân giải được (host not found in upstream).
WebSocket, bẫy include nhóm header chung và log để quan sát
WebSocket cần chuyển tiếp header nâng cấp, kèm read timeout dài hơn khoảng ping:
location /ws/ {
proxy_pass http://backend;
# location này có proxy_set_header riêng nên phải liệt kê lại header chung
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_read_timeout 1h;
}
Ở đây không include được file header chung nếu file đó có Connection "": hai dòng Connection sẽ cùng được gửi. Mình đã thử include một file có proxy_http_version vào location cũng có proxy_http_version: Nginx từ chối khởi động với lỗi "proxy_http_version" directive is duplicate. Header thì không báo lỗi trùng như vậy, nên càng phải để ý.
Quan sát. Ghi log JSON có $request_id, $upstream_addr, $upstream_status, $request_time (tổng thời gian) và $upstream_response_time (thời gian backend). Chênh lệch hai con số cuối cho biết chậm ở mạng tới client hay ở backend. Chuyển X-Request-Id (tốt hơn là traceparent) vào backend để nối với log ứng dụng, xem Distributed tracing với OpenTelemetry.
Bài tập
Bài 1: Route theo tên service như bài tập URL của khoá
Đề (diễn đạt lại): gateway đứng trước user-service và order-service. URL công khai có dạng /user-service/v1/users/34 và /order-service/v1/orders/145; mỗi service bên trong chỉ biết path /v1/.... Viết cấu hình Nginx.
Lời giải Bài 1: cấu hình gateway cắt prefix theo service
File snippets/proxy-headers.conf, dùng chung:
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
Cấu hình gateway:
upstream user_service { server user-service:8080; keepalive 16; }
upstream order_service { server order-service:8080; keepalive 16; }
server {
listen 80;
absolute_redirect off;
proxy_http_version 1.1;
include /etc/nginx/snippets/proxy-headers.conf;
location /user-service/ {
proxy_pass http://user_service/; # cắt prefix: /user-service/v1/users/34 -> /v1/users/34
proxy_set_header X-Forwarded-Prefix /user-service;
include /etc/nginx/snippets/proxy-headers.conf; # vì có proxy_set_header riêng ở đây
}
location /order-service/ {
proxy_pass http://order_service/;
proxy_set_header X-Forwarded-Prefix /order-service;
include /etc/nginx/snippets/proxy-headers.conf;
}
location / { return 404; }
}
Chạy thử (nginx -t qua, rồi gọi thật): /user-service/v1/users/34 tới user-service với path /v1/users/34 và header X-Forwarded-Prefix: /user-service; /order-service/v1/orders/145 tới order-service với /v1/orders/145; /other nhận 404.
Giải thích:
- Location và URI của
proxy_passcùng có/cuối nên prefix bị cắt sạch. - Mỗi location có
proxy_set_headerriêng (X-Forwarded-Prefix), nên nhóm header chung phảiincludelại ở location (quy tắc kế thừa ở mục 6). location / { return 404; }chặn mọi path không thuộc service nào, thay vì vô tình route về đâu đó.- Một senior sẽ hỏi thêm: URL công khai có nên lộ tên service không (xem trade-off trong REST API nâng cao).
Bài 2: Link http:// sau TLS
Đề: TLS kết thúc ở Nginx, Spring Boot phía sau chạy HTTP. Sau khi đăng nhập, user bị redirect về http://shop.vn/home và trình duyệt báo cảnh báo. Tìm nguyên nhân và sửa.
Lời giải Bài 2: X-Forwarded-Proto và forward-headers-strategy
Nguyên nhân: Spring dựng URL redirect từ request.getScheme() = http, vì nó nhận kết nối HTTP từ Nginx.
- Sửa ở hai đầu: Nginx gửi
proxy_set_header X-Forwarded-Proto $scheme;(vàHost $host); Spring Boot bậtserver.forward-headers-strategy=nativevớiinternal-proxieskhớp IP của Nginx. - Kiểm tra: gọi qua proxy một endpoint trả
request.getScheme()+getServerName(), phải thấyhttpsvàshop.vn. - Thêm HSTS ở Nginx (
add_header Strict-Transport-Security "max-age=31536000" always;) để trình duyệt không bao giờ thửhttp://nữa.
Bài 3: Đọc cấu hình, đoán kết quả
Cho:
location /static/ { root /var/www; }
location ~* \.(png|jpg)$ { root /var/cdn; }
location /api { proxy_pass http://be:8080/; }
Request GET /static/logo.png và GET /api/v2/products đi đâu?
Lời giải Bài 3: regex thắng prefix và lỗi dấu / cuối
Đã chạy thử, đúng như dưới đây.
/static/logo.pngkhớp prefix/static/, nhưng regex\.png$cũng khớp và regex thắng, nên file được đọc từ/var/cdn/static/logo.png. Sửa bằnglocation ^~ /static/./api/v2/productskhớplocation /api, phần/apibị thay bằng/, backend nhận//v2/products. Sửa bằnglocation /api/(giữproxy_pass http://be:8080/nếu muốn cắt prefix, hoặc bỏ/cuối củaproxy_passnếu muốn giữ).
Ghi nhớ
- Nói được thứ tự Nginx chọn
location, và vì sao một regex.pngcướp được request củalocation /api/. - Đoán được path backend nhận với mọi cặp location /
proxy_pass, kể cả//ordersvà/apiv2thành/v2. - Giải thích được vì sao không lấy phần tử đầu của
X-Forwarded-For, và cấu hình đúng ở Nginx lẫn Spring Boot. - Biết bẫy kế thừa
proxy_set_headervà cách tránh bằnginclude. - Liệt kê được các mặc định cần đổi cho production: timeout, keepalive, buffering, retry, body size, DNS upstream.
Câu hỏi phỏng vấn
Junior
Reverse proxy khác forward proxy thế nào?
Forward proxy đứng phía client và đi ra ngoài thay client; reverse proxy đứng phía server và nhận request vào thay các service.
Với forward proxy (proxy công ty), server đích chỉ thấy proxy. Với reverse proxy, client chỉ thấy một địa chỉ. Reverse proxy dùng để kết thúc TLS, route theo path hay host, cân bằng tải, nén, cache, rate limit, và giấu cấu trúc bên trong.
Vì sao backend sau proxy cần header X-Forwarded-For và X-Forwarded-Proto?
Vì kết nối tới backend đến từ proxy: IP nguồn là IP proxy, scheme là HTTP nếu TLS kết thúc ở proxy.
Không có các header này thì log và rate limit thấy toàn IP proxy, còn link và redirect app tạo ra dùng http:// sai. X-Forwarded-For mang chuỗi IP qua từng hop, X-Forwarded-Proto mang scheme client dùng.
Mid
location /api/ { proxy_pass http://be:8080; } và proxy_pass http://be:8080/; khác nhau gì?
Không có URI thì path giữ nguyên (/api/orders); có URI / thì phần khớp location bị thay, backend nhận /orders.
Hai cái phải đi đôi: location có / cuối thì URI cũng có, nếu không sẽ ra //orders hoặc /apiv2 thành /v2.
Nginx chọn location theo thứ tự nào?
Nhớ prefix khớp dài nhất, dừng nếu có = khớp chính xác hoặc prefix đó có ^~, rồi regex đầu tiên khớp theo thứ tự file thắng; không regex nào khớp thì dùng prefix đã nhớ.
Hệ quả: một regex bắt đuôi .png có thể cướp request của location /api/.
Bật keepalive tới upstream cần những gì và để làm gì?
Cần keepalive N trong upstream, proxy_http_version 1.1 và proxy_set_header Connection "", để dùng lại kết nối thay vì mở mới mỗi request.
Connection "" để Nginx không gửi Connection: close. Lợi ích: không phải bắt tay TCP (và TLS nếu có) cho mỗi request, giảm latency và tránh hàng chục nghìn socket TIME_WAIT làm cạn port ở tải cao.
Bạn bật SSE qua Nginx nhưng client nhận event theo từng cục lớn. Vì sao?
Vì proxy_buffering mặc định bật, Nginx gom response vào buffer rồi mới gửi.
Tắt cho location đó (proxy_buffering off;) hoặc backend gửi X-Accel-Buffering: no. Đồng thời tăng proxy_read_timeout vượt khoảng heartbeat để kết nối không bị cắt sau 60 giây.
Senior
Làm sao lấy đúng IP client khi có nhiều lớp proxy?
Đọc X-Forwarded-For từ phải sang trái, bỏ qua IP proxy của mình; IP đầu tiên không tin cậy là client.
- Không lấy phần tử đầu vì client tự đặt được. Lớp ngoài cùng nên ghi đè header bằng
$remote_addr. - Nginx:
set_real_ip_fromvớireal_ip_recursive on. Spring Boot:forward-headers-strategy=nativevàinternal-proxiesđúng dải của load balancer. - Đi qua L4 load balancer thì không có header HTTP, dùng PROXY protocol.
Proxy có nên tự retry request khi backend lỗi không?
Lỗi kết nối trước khi gửi thì retry an toàn; timeout sau khi gửi thì chỉ an toàn với request idempotent.
- Nginx mặc định không retry POST/PATCH vì backend có thể đã xử lý.
- Kể cả GET, phải giới hạn số lần và tổng thời gian retry: khi cả cụm quá tải, retry nhân tải và làm sự cố lan rộng.
- Retry nên ở một tầng duy nhất có backoff, không phải ở cả client, gateway và service.
Sau khi deploy lại backend trong Docker, Nginx trả 502 tới khi reload. Giải thích và sửa.
Nginx open source phân giải tên upstream một lần lúc start/reload và giữ IP đó; container mới có IP khác nên kết nối tới IP cũ thất bại.
Sửa: dùng tên có IP ổn định (Service của Kubernetes), hoặc resolver + biến trong proxy_pass để phân giải lại theo TTL, hoặc tham số resolve trong upstream (từ 1.27.3). Nếu giữ cách tĩnh thì thêm reload vào quy trình deploy.
Khi nào bạn dùng API gateway thay vì Nginx?
Khi cần logic theo API mà cấu hình Nginx tĩnh làm vất vả; nếu chỉ cần một cửa vào với TLS, route theo path và rate limit theo IP thì Nginx đơn giản hơn.
Logic theo API gồm: xác thực JWT hay API key cho đối tác, quota theo client, canary theo header, đổi route thường xuyên không reload, nhiều team cùng sửa route. Nginx ít thành phần phải vận hành hơn. Dù chọn gì, tránh để gateway chứa logic nghiệp vụ.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu tiếng Anh dùng trong phỏng vấn |
|---|---|---|---|
| reverse proxy | /rɪˈvɜːs ˈprɒksi/ | proxy đứng trước server | “The reverse proxy terminates TLS and routes by path.” |
| upstream | /ˌʌpˈstriːm/ | server phía sau mà proxy chuyển tới | “Nginx returned 502 because the upstream had a new IP.” |
| path-based routing | /pɑːθ beɪst ˈruːtɪŋ/ | định tuyến theo path | “We use path-based routing: /api goes to the backend, everything else to the frontend.” |
| strip the prefix | /strɪp ðə ˈpriːfɪks/ | cắt prefix khỏi path | “The proxy strips the /blog prefix before forwarding.” |
| trailing slash | /ˈtreɪlɪŋ slæʃ/ | dấu / ở cuối | “A missing trailing slash in the location turned /api/orders into //orders.” |
| TLS termination | /ˌtiː el ˈes ˌtɜːmɪˈneɪʃn/ | giải mã TLS tại proxy | “With TLS termination at Nginx, the app sees plain HTTP.” |
| hop | /hɒp/ | một chặng qua proxy | “Each hop appends its peer address to X-Forwarded-For.” |
| trusted proxy | /ˈtrʌstɪd ˈprɒksi/ | proxy mình tin header của nó | “We only honour forwarded headers from trusted proxies.” |
| spoof | /spuːf/ | giả mạo | “A client can spoof the first X-Forwarded-For entry.” |
| keepalive connection | /ˈkiːp əˌlaɪv kəˈnekʃn/ | kết nối được dùng lại | “Keepalive connections to the upstream removed thousands of TIME_WAIT sockets.” |
Tham khảo
- nginx: ngx_http_proxy_module (
proxy_pass,proxy_set_header, timeout, buffering,proxy_next_upstream) - nginx: ngx_http_core_module,
location - nginx: ngx_http_realip_module
- nginx: ngx_http_upstream_module (
keepalive,resolve) - RFC 7239: Forwarded HTTP Extension
Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.