HTTP అంటే ఏమిటి? Server admin కోసం పూర్తి గైడ్
HTTPలో methods, status codes, ముఖ్యమైన headers, nginx logs ఏమి చూపిస్తాయో తెలుసుకోండి. HTTP/3 మరియు TLS ఎక్కడ సరిపోతాయో కూడా సులభంగా అర్థం చేసుకోండి.
HTTP అంటే ఏమిటి?
HTTP (hypertext transfer protocol) అనేది క్లయింట్ మరియు web server ఏదైనా వనరును అభ్యర్థించి, దాని ప్రతిస్పందనను తిరిగి పంపేందుకు ఉపయోగించే నియమాల సమాహారం. క్లయింట్ ఒక request పంపుతుంది. అందులో GET వంటి method, /pricing వంటి path, protocol version, headers జాబితా, కొన్నిసార్లు body ఉంటాయి. Server 200 వంటి status code తో ప్రతిస్పందిస్తుంది. దాని తరువాత server headers మరియు సాధారణంగా body పంపుతుంది. మీ server లో కనిపించే ప్రతి page view మరియు ప్రతి API (application programming interface) call ఇదే exchange పునరావృతం కావడం.
HTTP తనంతట తాను state ను నిల్వ చేయదు. ఒక సెకను ముందు మీరు ఏది అభ్యర్థించారో server గుర్తుంచుకోదు. అందువల్ల login session వంటి memory లాగా పనిచేసే సమాచారం ప్రతి request లోని header ద్వారా పంపాలి. తరువాతి విషయాలలో ఎక్కువ భాగాన్ని ఈ లక్షణమే వివరిస్తుంది. Caching పూర్తిగా headers ఆధారంగా పనిచేస్తుంది. అలాగే load balancer మీ తరువాతి request ను వేరే backend కు పంపినా ఎలాంటి సమస్య ఉండదు.
క్రిందివన్నీ server వైపు ఈ మోడల్ ఎలా కనిపిస్తుందో వివరిస్తాయి. అవి మీ access log మరియు nginx config లో కనిపిస్తాయి.
వివరణలతో కూడిన raw request మరియు response
ఇది పూర్తి HTTP/1.1 request. ఖాళీ line headers ను ముగిస్తుంది. ఆ line తర్వాత ఉన్నది body. సాధారణంగా GET కు body ఉండదు.
GET /pricing HTTP/1.1
Host: example.com
User-Agent: curl/8.5.0
Accept: */*
Accept-Encoding: gzipGETఅనేది method. ఇది ఏ చర్య చేయాలో చెబుతుంది.GETచదువుతుంది,POSTడేటాను పంపుతుంది,PUTస్థానంలో కొత్తదాన్ని ఉంచుతుంది,DELETEతొలగిస్తుంది,HEADbody లేకుండాGETheaders ను మాత్రమే అడుగుతుంది./pricingఅనేది path. Hostname request line లో భాగం కాదు. అందుకే తరువాతి header అవసరం.HTTP/1.1అనేది client ఉపయోగిస్తున్న protocol version.Host: example.comద్వారా client కోరుతున్న site పేరు తెలుస్తుంది. HTTP/1.1 లో ఇది తప్పనిసరి. అందువల్ల ఇది లేకుండా వచ్చిన request కు nginx400 Bad Requestతో సమాధానం ఇస్తుంది.- మిగతావి preferences. Client decompress చేయగలదని
Accept-Encoding: gzipచెబుతుంది. కాబట్టి server body ను compress చేయవచ్చు.
Response కూడా ఇదే నిర్మాణాన్ని కలిగి ఉంటుంది. అయితే పైభాగంలో status line ఉంటుంది.
HTTP/1.1 200 OK
Date: Thu, 06 Aug 2026 09:12:44 GMT
Server: nginx
Content-Type: text/html; charset=utf-8
Content-Length: 5310
Cache-Control: public, max-age=300
<!doctype html>...200 OKఅనేది reason phrase తో కూడిన status code. ముఖ్యమైనది code మాత్రమే. Phrase అలంకార సమాచారం. Clients దాన్ని పట్టించుకోవు.- తరువాత వచ్చే bytes ను client ఎలా నిర్వహించాలో
Content-Typeచెబుతుంది. Content-Lengthఅనేది bytes లో body పరిమాణం. అందువల్ల body ఎక్కడ ముగుస్తుందో client కు తెలుస్తుంది. పరిమాణం ముందుగా తెలియకపోతే server దాని బదులుTransfer-Encoding: chunkedపంపుతుంది. ముగింపును zero length chunk తో సూచిస్తుంది.- ఈ response ను ఎంతకాలం fresh గా పరిగణించవచ్చో browser కు, మధ్యలో ఉన్న ఏ cache కైనా
Cache-Controlచెబుతుంది. దాని వయస్సుmax-ageseconds దాటిన తర్వాత అది stale అవుతుంది. అంటే అది తొలగించబడిందని కాదు. Cache stale copy ను ఉంచి, మొత్తం body ను మళ్లీ download చేయకుండా మీ server తో revalidate చేయవచ్చు. - Headers తర్వాత ఉన్న ఖాళీ line, రెండు దిశల్లోనూ headers ను body నుంచి వేరు చేస్తుంది.
Header names విషయంలో uppercase, lowercase తేడా ఉండదు. ప్రతి line చివర bare newline కాకుండా carriage return తరువాత line feed ఉంటుంది. మీరు వీటిని చేతితో type చేయరు. కానీ packet capture లో ఇవి కనిపిస్తాయి.
నిజమైన request-response జంటను చూడటానికి, మీకు చెందిన site పై దీన్ని run చేయండి:
curl -sS -o /dev/null -D - https://example.com/-D - response headers ను మీ terminal లో రాస్తుంది. -o /dev/null body ను విస్మరిస్తుంది. దీనికి బదులుగా curl -I ను ఉపయోగించడం మంచిది. ఎందుకంటే -I ఒక HEAD request పంపుతుంది. HEAD ను GET కంటే భిన్నంగా నిర్వహించే application server లు చాలా ఉన్నాయి. అప్పుడు browser ఎప్పుడూ స్వీకరించని headers ను మీరు చూస్తారు. curl -v రెండు వైపుల సమాచారాన్ని print చేస్తుంది. Request lines ను > తో, response lines ను < తో గుర్తిస్తుంది.
మీ nginx access log లో request line ఎలా కనిపిస్తుంది
nginx ఒక combined log format ను అందిస్తుంది, దాని నిర్వచనం ఇక్కడ ఉంది:
log_format combined '$remote_addr - $remote_user [$time_local] '
'"$request" $status $body_bytes_sent '
'"$http_referer" "$http_user_agent"';దీని ద్వారా తయారైన ఒక line:
203.0.113.45 - - [06/Aug/2026:09:12:44 +0000] "GET /pricing HTTP/1.1" 200 5310 "https://example.com/" "Mozilla/5.0 (X11; Linux x86_64) Chrome/127.0.0.0 Safari/537.36"203.0.113.45అనేది$remote_addr, ఇది TCP (transmission control protocol) కనెక్షన్ను ప్రారంభించిన చిరునామా. proxy వెనుక ఉన్నప్పుడు, మీరు కింద వివరించిన realip module ను కాన్ఫిగర్ చేసి దానిని మార్చకపోతే, ఇది సందర్శకుడి చిరునామా కాకుండా proxy చిరునామాను చూపిస్తుంది.- మొదటి
-ఒక స్థిరమైన placeholder. రెండవది$remote_user, ఇది HTTP basic authentication వాడుకలో ఉన్నప్పుడు మాత్రమే నింపబడుతుంది. "GET /pricing HTTP/1.1"అనేది$request, ఇది పూర్తి అసలు request line. nginx యొక్క డిఫాల్ట్ log escaping తో, double quote, backslash మరియు 32 కంటే తక్కువ లేదా 126 కంటే ఎక్కువ ఉన్న ఏ byte అయినా\xXXగా వ్రాయబడుతుంది, కాబట్టి ఈ line ఖచ్చితమైనది కానీ ఎల్లప్పుడూ byte-to-byte సమానంగా ఉండదు.200అనేది మీ సర్వర్ తిరిగి పంపిన status, సందర్శకుడు చూసిన status కాదు.5310అనేది$body_bytes_sent, ఇది కేవలం body పరిమాణం మాత్రమే. Response headers లెక్కించబడవు, కాబట్టి ఈ సంఖ్య వాస్తవంగా పంపిన bytes కంటే ఎల్లప్పుడూ తక్కువగా ఉంటుంది.- చివరి రెండు quoted fields
RefererమరియుUser-Agent. ఇవి రెండూ client నుండి వస్తాయి, కాబట్టి వీటిలో ఏదైనా ఉండవచ్చు.
అనవసరమైన సమాచారం (Junk) కూడా escaped రూపంలో log చేయబడుతుంది. మీ plaintext port 80 కి TLS (transport layer security) ద్వారా మాట్లాడే client ఒక 400 line ను వదులుతుంది, దాని request field లో "\x16\x03\x01\x02\x00\x01" వంటి escaped bytes ఉంటాయి. \x16 అనేది TLS handshake record రకం, కాబట్టి ఆ bytes ఒక ClientHello యొక్క ప్రారంభం తప్ప request line కాదు. మీ సర్వర్ సరిగ్గా పనిచేస్తోంది. ఎవరో HTTPS ను HTTP port కి పంపుతున్నారు.
మీ log format కు $server_protocol ను కూడా జోడించండి. ఇది HTTP/1.1, HTTP/2.0 లేదా HTTP/3.0 ను ప్రింట్ చేస్తుంది, మరియు protocol మార్పు నిజంగా అమల్లోకి వచ్చిందని నిరూపించడానికి ఇది వేగవంతమైన మార్గం.
మీ స్వంత సైట్ ఈ సాధారణ status codes ను తిరిగి పంపినప్పుడు వాటి అర్థం
మొదటి అంకె ఆ వర్గాన్ని సూచిస్తుంది. ముందుగా చదవాల్సింది కూడా ఆ వర్గమే.
2xx అంటే అభ్యర్థన విజయవంతమైంది. సాధారణ read కోసం 200 OK. ఏదైనా సృష్టించిన POST తర్వాత 201 Created. తిరిగి పంపాల్సినదేమీ లేని విజయవంతమైన అభ్యర్థనకు 204 No Content. DELETE కు సాధారణంగా ఇదే సమాధానం.
3xx అంటే వేరే చోట చూడాలి. 301 శాశ్వత redirect. Browsers దీన్ని బలంగా cache చేస్తాయి. కొన్నిసార్లు user తన profile ను clear చేసే వరకు కూడా అలాగే ఉంచుతాయి. అందువల్ల తప్పు hostname వైపు చూపించే 301 ను సరిచేయడం కష్టంగా ఉంటుంది. Redirect ను ఇంకా పరీక్షిస్తున్నప్పుడు 302 ఉపయోగించండి. 304 Not Modified error కాదు, success. Client conditional request పంపినప్పుడు ఇది వస్తుంది. ఆ request లో మీరు ఇంకా గుర్తించే ETag (entity tag) ఉన్న If-None-Match ఉండవచ్చు. లేదా resource ఈ తేదీ తర్వాత మారలేదని సూచించే తేదీతో If-Modified-Since ఉండవచ్చు. అందువల్ల మీరు headers మాత్రమే పంపి body పంపలేదు. Logs లో 304లు ఎక్కువగా కనిపిస్తే caching సరిగా పనిచేస్తోందని అర్థం.
4xx అంటే request లో తప్పు ఉంది. 400 Bad Request అంటే input సరైన ఆకృతిలో లేదని అర్థం. 401 Unauthorized అంటే authentication జరగలేదని అర్థం. ఇందులో scheme పేరును సూచించే WWW-Authenticate header తప్పనిసరిగా ఉండాలి. 403 Forbidden అంటే request అర్థమైంది, అయినప్పటికీ దాన్ని తిరస్కరించారు. 404 Not Found అంటే ఆ path లేదు. లేదా అది ఉందని server వెల్లడించకూడదనుకుంటోంది. Access లేని clients కు resource కనిపించకుండా చేయడానికి కొన్ని applications 403 బదులుగా 404 ను పంపుతాయి. 405 Method Not Allowed అంటే path సరైనదే కానీ method తప్పు. Static file location కు POST పంపినప్పుడు సాధారణంగా ఇదే వస్తుంది. 413 అంటే nginx యొక్క client_max_body_size పరిమితి కంటే body పెద్దదిగా ఉందని అర్థం. దీని default విలువ 1 megabyte. Error log లో ఇది client intended to send too large body గా నిర్ధారించబడుతుంది.
Static file కు 403 వస్తే, కారణం దాదాపు ఎల్లప్పుడూ HTTP rule కాదు, filesystem. ఏ configuration మార్చే ముందు /var/log/nginx/error.log ను చదవండి. open() "/srv/site/index.html" failed (13: Permission denied) అంటే nginx worker user కు file చదివే అనుమతి లేదని అర్థం. Parent directory కి others కోసం execute permission లేకపోవడం దీనికి అత్యంత సాధారణ కారణం. directory index of "/srv/site/" is forbidden అంటే path index file లేని directory కి resolve అయిందని అర్థం. ఈ సమయంలో autoindex off లో ఉంటుంది.
5xx అంటే మీ వైపు లోపం జరిగింది. 500 సాధారణ server error code. మీ స్వంత site లో ఇది సాధారణంగా application లో handle చేయని error ను సూచిస్తుంది. 502 Bad Gateway అంటే nginx కు upstream నుంచి ఉపయోగించగల response అందలేదని అర్థం. Error log కారణాన్ని చూపిస్తుంది. connect() failed (111: Connection refused) while connecting to upstream అంటే proxy_pass లోని address పై ఏదీ listen చేయడం లేదని అర్థం. 504 Gateway Timeout అంటే nginx upstream కోసం వేచి ఉండటం ఆపేసిందని అర్థం. సాధారణంగా upstream connection ను స్వీకరించిన తర్వాత proxy_read_timeout లోపు, default గా 60 seconds లోపు, ఏ response ఇవ్వదు. Log లో ఇది upstream timed out (110: Connection timed out) while reading response header from upstream గా నమోదవుతుంది. Connection attempt proxy_connect_timeout లోపు పూర్తికాకపోతే, ఇది కూడా default గా 60 seconds, 504 వస్తుంది. అప్పుడు log line while connecting to upstream తో ముగుస్తుంది. 503 Service Unavailable అంటే server తాత్కాలికంగా request ను handle చేయలేకపోతోందని అర్థం. సాధారణంగా server పై అధిక load ఉండటం లేదా scheduled maintenance కోసం అది down లో ఉండటం కారణం. nginx యొక్క rate limiter 503 ను తిరిగి పంపుతుందని గమనించండి. ఎందుకంటే limit_req_status యొక్క default విలువ 503. మీ log లో 429 Too Many Requests కోసం వెతికినా 503 మాత్రమే కనిపిస్తే కారణం ఇదే. సరైన code పొందడానికి limit_req_status 429; ను సెట్ చేయండి.
సర్వర్ను రన్ చేస్తున్నప్పుడు ముఖ్యమైన headers
Host సైట్ను ఎంచుకుంటుంది. ఒకే IP అడ్రస్ వందలాది hostnames కు సేవలను అందించగలదు. ఏ server బ్లాక్ సమాధానం ఇవ్వాలో నిర్ణయించడానికి nginx, Host ను server_name తో సరిపోల్చుతుంది. ఏదీ సరిపోలకపోతే, nginx డిఫాల్ట్ సర్వర్ను ఉపయోగిస్తుంది. మరొక బ్లాక్ను default_server గా గుర్తించకపోతే, ఆ అడ్రస్ మరియు పోర్ట్ వద్ద వింటున్న మొదటి బ్లాక్ డిఫాల్ట్ సర్వర్గా పనిచేస్తుంది. కొత్త virtual host నుండి తప్పుడు సైట్ వస్తుంటే, దాదాపు ఎప్పుడూ ఇదే కారణం: పేరు సరిపోలలేదు, కాబట్టి అభ్యర్థన డిఫాల్ట్ సర్వర్కు వెళ్ళింది. DNS తో సంబంధం లేకుండా దీన్ని ఇలా పరీక్షించండి:
curl -sS -o /dev/null -D - -H 'Host: app.example.com' http://127.0.0.1/User-Agent అనేది క్లయింట్ తన గురించి తాను ఇచ్చుకునే వివరణ, ఇది ఒక ఉచిత టెక్స్ట్. లాగ్స్ చదివేటప్పుడు దీనిని ఒక సూచనగా మాత్రమే ఉపయోగించండి. దీనిని నియంత్రణ సాధనంగా ఎప్పుడూ వాడకండి, ఎందుకంటే అబద్ధం చెప్పాలనుకునే క్లయింట్ సులభంగా అలా చేయగలదు. కాబట్టి, User-Agent ద్వారా స్క్రాపర్ను బ్లాక్ చేయడం వల్ల కేవలం మర్యాదపూర్వకమైనవి మాత్రమే ఫిల్టర్ అవుతాయి.
Content-Type అనేది బైట్లను ఎలా అర్థం చేసుకోవాలో నిర్ణయిస్తుంది: API అభ్యర్థన కోసం application/json, ఒక పేజీ కోసం text/html; charset=utf-8. Nginx ఫైల్ ఎక్స్టెన్షన్లను /etc/nginx/mime.types తో రకాలను మ్యాప్ చేస్తుంది, మరియు ప్యాక్ చేయబడిన nginx.conf అనేది default_type application/octet-stream; ని సెట్ చేస్తుంది. కాబట్టి, Nginx కు తెలియని ఎక్స్టెన్షన్ ఉన్న ఫైల్ రెండర్ అవ్వడానికి బదులుగా డౌన్లోడ్గా చూపబడుతుంది. దీనివల్ల కనిపించే ప్రధాన లక్షణం ఏమిటంటే, పేజీ స్టైలింగ్ లేకుండా లోడ్ అవుతుంది మరియు బ్రౌజర్ కన్సోల్ Refused to apply style from ... because its MIME type ('text/plain') is not a supported stylesheet MIME type ని ప్రింట్ చేస్తుంది. ఇక్కడ MIME అంటే Multipurpose Internet Mail Extensions, ఈ టైప్ స్ట్రింగ్లు వచ్చే నామింగ్ స్కీమ్ ఇదే.
Cache-Control అనేది మీ సర్వర్ మరియు రీడర్ మధ్య ఉన్న ప్రతి కాష్ను మీరు నియంత్రించే విధానం. public, max-age=31536000, immutable అనేది ఫైల్నేమ్లో కంటెంట్ హ్యాష్ (content hash) ఉన్న అసెట్లకు సరిపోతుంది, ఎందుకంటే కంటెంట్ మారినప్పుడు ఫైల్ పేరు కూడా మారుతుంది. no-store అనేది వినియోగదారునికి సంబంధించిన ఏదైనా సమాచారం కోసం వాడాలి, ఎందుకంటే లాగిన్ అయిన పేజీని భద్రపరిచే షేర్డ్ కాష్ (shared cache), అదే URL కోసం అడిగే తదుపరి వ్యక్తికి ఆ సమాచారాన్ని ఇచ్చే ప్రమాదం ఉంది. private అనేది మధ్యస్థ సెట్టింగ్: బ్రౌజర్ దీనిని ఉంచుకోవచ్చు, కానీ షేర్డ్ కాష్ ఉంచుకోకూడదు.
X-Forwarded-For ఎందుకు అవసరం
ఒక proxy సందర్శకుడిని దాచిపెడుతుంది కాబట్టి X-Forwarded-For అవసరమవుతుంది. ఒక అభ్యర్థన reverse proxy ద్వారా వెళ్ళినప్పుడు, $remote_addr అనేది proxy యొక్క చిరునామాగా మారుతుంది. దీనివల్ల, మీరు అసలు చిరునామాను పునరుద్ధరించే వరకు మీ logs, geolocation మరియు rate limiting అన్నీ ఒకే client ను మాత్రమే చూస్తాయి. కాబట్టి, proxy అసలు చిరునామాను ముందుకు పంపాల్సి ఉంటుంది:
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;తరువాత, స్వీకరించే సర్వర్కు ఆ సమాచారాన్ని నమ్మాలని మరియు ఎవరిని నమ్మాలో ఖచ్చితంగా తెలియజేయాలి:
set_real_ip_from 10.0.0.0/8;
real_ip_header X-Forwarded-For;Nginx realip మాడ్యూల్
ఈ రెండు directives Nginx యొక్క realip మాడ్యూల్కు చెందినవి. ఇవి $remote_addr ను ఫార్వర్డ్ చేయబడిన అడ్రస్తో భర్తీ చేస్తాయి మరియు కనెక్షన్ యొక్క సొంత అడ్రస్ను $realip_remote_addr లో ఉంచుతాయి. మీరు Nginx ను సొంతంగా కంపైల్ చేస్తుంటే, --with-http_realip_module ను జోడించండి, ఎందుకంటే ఈ మాడ్యూల్ డిఫాల్ట్గా బిల్డ్ చేయబడదు.
మీరు నియంత్రించే పరిధులను మాత్రమే జాబితా చేయండి. X-Forwarded-For అనేది ఏ క్లయింట్ అయినా పంపగల సాధారణ వచనం, కాబట్టి set_real_ip_from 0.0.0.0/0; ద్వారా మీరు లాగ్ చేసే చిరునామాను మరియు మీ రేట్ లిమిటర్ లెక్కించే చిరునామాను సందర్శకుడు ఎంచుకునేలా చేస్తుంది.
###
X-Forwarded-Proto ఒక నిర్దిష్టమైన మరియు సాధారణ వైఫల్యాన్ని నివారిస్తుంది. మీ proxy TLS ను terminate చేసి, అభ్యర్థనను plain HTTP ద్వారా అప్లికేషన్కు పంపుతుంది. అప్లికేషన్ ఆ అభ్యర్థనను plain గా చూసి, సందర్శకుడు HTTPS లో ఉండాలని నిర్ణయించుకుని, 301 https://example.com/ తో సమాధానమిస్తుంది. బ్రౌజర్ ఆ సూచనను అనుసరిస్తుంది, proxy మళ్ళీ TLS ను terminate చేసి plain HTTP ని పంపుతుంది; బ్రౌజర్ ERR_TOO_MANY_REDIRECTS తో విరమించుకునే వరకు ఈ లూప్ కొనసాగుతుంది. X-Forwarded-Proto: https ని పంపడం ద్వారా, సందర్శకుడు ఇప్పటికే HTTPS లో ఉన్నాడని అప్లికేషన్కు తెలుస్తుంది, కాబట్టి అది redirect చేయడం ఆపివేస్తుంది.
మీ కోసం HTTP/1.1, HTTP/2, HTTP/3లో మారేది ఏమిటి
HTTP/1.1 టెక్స్ట్ ఆధారితం. ఆచరణలో ప్రతి connectionకు ఒకేసారి ఒక requestను మాత్రమే నిర్వహిస్తుంది. Connection: keep-alive వల్ల తదుపరి request అదే TCP connectionను తిరిగి ఉపయోగించగలదు. దీనివల్ల setup ఖర్చు తగ్గుతుంది. అయితే responses request చేసిన క్రమంలోనే తిరిగి వస్తాయి. Client సమాధానాల కోసం వేచి ఉండకుండా అనేక requestsను వరుసగా పంపే pipeliningకు కూడా protocol అనుమతిస్తుంది. కానీ క్రమ నియమం అలాగే ఉంటుంది. ఆధునిక browser ఏదీ pipeliningను defaultగా enable చేయదు. ఒక response నెమ్మదిగా ఉంటే, దాని వెనుక queueలో ఉన్న ప్రతిదీ ఆగిపోతుంది. దీనినే head-of-line blocking అంటారు. దీన్ని నివారించడానికి browsers ఒకే hostnameకు ఒకేసారి అనేక connectionsను తెరుస్తాయి.
HTTP/2లో అదే methods, అదే status codes కొనసాగుతాయి. అయితే framing binaryగా మారుతుంది. అనేక requests ఒకే connectionను independent streamsగా పంచుకుంటాయి. తిరిగి వచ్చే header text compress అవుతుంది. ఆధునిక requestలో header text ఎక్కువగా ఉండటం వల్ల ఇది ముఖ్యమైనది. Connection ఇప్పటికీ TCPపైనే ఉంటుంది. అందువల్ల ఒక packet పోతే, retransmission వచ్చే వరకు ఆ connectionలోని ప్రతి stream ఆగిపోతుంది. Head-of-line blocking తొలగిపోలేదు. అది HTTP స్థాయి నుంచి transport స్థాయికి మారింది. Server push HTTP/2లో భాగంగా ఉండేది. కానీ Chrome 2022లో దానికి support తొలగించినందున, ఆచరణలో అది ఇక లేదు.
HTTP/3 మళ్లీ అదే semanticsను కొనసాగిస్తుంది. TCP స్థానంలో UDPపై నిర్మించిన transport అయిన QUICను ఉపయోగిస్తుంది. QUIC streams దిగువ transport స్థాయి వరకు కూడా independentగా ఉంటాయి. అందువల్ల ఒక packet పోతే, అది చెందిన stream మాత్రమే ఆగుతుంది. TLS 1.3ను పై పొరగా అమర్చకుండా QUIC handshakeలోనే నిర్మించారు. అందువల్ల కొత్త connectionకు తక్కువ round trips అవసరం. దీనివల్ల రెండు ఆచరణాత్మక విషయాలు ఉంటాయి. HTTP/3 కోసం server ఉపయోగించే UDP port, మార్గంలోని ప్రతి firewallలో openగా ఉండాలి. UDPను throttle చేసే లేదా block చేసే ఏ network అయినా clientsను తిరిగి HTTP/2కు పంపుతుంది. ఆ port సాధారణంగా 443. అయితే protocol ఏ UDP portనైనా ఉపయోగించడానికి అనుమతిస్తుంది. ఎందుకంటే browsersను HTTP/3కు మళ్లించే advertisementలో portను స్పష్టంగా పేర్కొంటారు.
మీ కోసం concretely మారేది ఏమిటి. Browsers సాధారణంగా HTTP/3తో ప్రారంభించవు. అవి HTTP/2 లేదా HTTP/1.1 ద్వారా connect అవుతాయి. Responseలో Alt-Svc: h3=":443"; ma=86400 headerను చూసిన తరువాత, ఆ hostకు చేసే తదుపరి connections కోసం HTTP/3ను ఉపయోగిస్తాయి. DNSలోని HTTPS recordలో alpn value h3ను జాబితా చేసే సందర్భం దీనికి మినహాయింపు. అప్పుడు Firefox వంటి browser మొదటి connectionలోనే HTTP/3ను open చేయగలదు. ఆ record అదనపు సూచన మాత్రమే. ఇది headerకు ప్రత్యామ్నాయం కాదు. కాబట్టి headerను ఐచ్ఛిక అలంకరణగా పరిగణించకూడదు. ఇది ప్రధాన discovery mechanism. nginxలో version 1.25.1 నుంచి HTTP/2కు ప్రత్యేక directive వచ్చింది (server blockలో http2 on;; ఇది పాత listen ... http2 parameterను భర్తీ చేస్తుంది). QUIC mainline 1.25.0లో వచ్చింది. అక్కడ HTTP/3 siteకు సాధారణ listen 443 ssl;తో పాటు listen 443 quic reuseport; కూడా అవసరం. HTTP/3 module defaultగా build చేయబడదు (--with-http_v3_module). nginx documentation ఇప్పటికీ దాని supportను experimentalగా పేర్కొంటుంది.
ఇక్కడ proxies పరిపక్వతలో వేర్వేరుగా ఉంటాయి. మీరు అమలు చేస్తున్న versionకు ఇది సరిపోతుందో పరిశీలించాలి. November 2026 నాటికి, Caddy ఎటువంటి configuration లేకుండానే HTTP/3ను defaultగా అందిస్తుంది. nginxకు పైన వివరించిన explicit quic listenerతో పాటు Alt-Svc header అవసరం. Traefikలో ప్రతి entry pointకు explicit http3 option ద్వారా దీన్ని enable చేస్తారు. మీరు అనేక Docker apps ముందు Traefikను ఉంచి TLSను terminate చేస్తే, visitors పొందే protocol version అక్కడే నిర్ణయించబడుతుంది. Browser ఏ protocolను negotiate చేసినా, proxy నుంచి మీ containerకు వెళ్లే hop సాధారణంగా plain HTTP/1.1గానే ఉంటుంది.
ఊహించకుండా నిర్ధారించండి. curl --http3 -sS -o /dev/null -D - https://example.com/ పనిచేయాలంటే curl -Vలో దాని featuresలో HTTP3 జాబితా అయి ఉండాలి. చాలా distribution buildsలో ఇది ఉండదు. విశ్వసనీయమైన తనిఖీ మీ స్వంత log. Formatకు $server_protocolను జోడించి, వాస్తవ browsers ఏ protocolను negotiate చేస్తున్నాయో చదవండి. ఇవన్నీ చేయడానికి ముందు, మీ quic listener ఉపయోగించే UDP port, పై configurationలో 443, నిజంగా openగా ఉందో నిర్ధారించండి. TCP 443ను మాత్రమే అనుమతించే firewall HTTP/3ను నిశ్శబ్దంగా విఫలమయ్యేలా చేస్తుంది. Site మాత్రం HTTP/2 ద్వారా పనిచేస్తూనే ఉంటుంది. మీ Linux serverలో ఏ ports openగా ఉండి listeningలో ఉన్నాయో తెలుసుకోవడం మొదట తనిఖీ చేయాల్సిన విషయం.
HTTPS: HTTP ప్రోటోకాల్, TLS దాని రక్షణ పొర
HTTPS ప్రత్యేకమైన ప్రోటోకాల్ కాదు. ఇది TLS session లోపల పంపబడే అదే requests మరియు అదే status codes. Port 80 వాటిని plain text గా పంపుతుంది. Port 443 వాటిని encrypted గా పంపుతుంది. ముందుగా TLS handshake పూర్తవుతుంది. తరువాత HTTP request encrypted channel లో ప్రయాణిస్తుంది. ఈ క్రమం వల్ల certificate సమస్యకు status code ఉండదు. ఒక్క HTTP byte కూడా పంపకముందే వైఫల్యం జరుగుతుంది. అందువల్ల number చేయడానికి response ఉండదు.
అనేక sites ను host చేస్తున్న server లో ఒక క్రమ వివరానికి ప్రాధాన్యం ఉంది. SNI (server name indication) ఉపయోగించి certificate ఎంచుకోబడుతుంది. ఇది TLS handshake లోని field. ఏ HTTP header ఉండకముందే ఇది hostname ను plain text గా పంపుతుంది. అందువల్ల server మొదట SNI ఆధారంగా certificate ఎంచుకుంటుంది. తరువాత Host header ఆధారంగా virtual host ను ఎంచుకుంటుంది. ఇవి సాధారణంగా ఒకదానితో ఒకటి సరిపోయే రెండు వేర్వేరు lookups. అవి సరిపోకపోతే browser NET::ERR_CERT_COMMON_NAME_INVALID వంటి name mismatch ను చూపిస్తుంది. మీ default server certificate ఆ hostname ను cover చేయనప్పటికీ దానిని అందించినందున browser ఎలాంటి request ను పంపదు.
Public site కోసం నిజమైన certificate పొందండి. దాన్ని స్వయంచాలకంగా renew అయ్యేలా చేయండి. nginx లో Let's Encrypt తో Certbot మీ server block లో certificate paths ను రాస్తుంది. Renewal timer ను కూడా మీ కోసం install చేస్తుంది. Public authority validate చేయలేని hostname కోసం, ఉదాహరణకు internal name లేదా మీ స్వంత network లోని bare IP address కోసం, Ubuntu లో self-signed certificate సరైన ఎంపిక. అయితే ప్రతి client దానిని trust చేయాలని మీరు చెప్పాల్సి ఉంటుంది.
TLS పనిచేసిన తర్వాత port 80 లోని ప్రతిదాన్ని port 443 కు పంపండి:
server {
listen 80;
server_name example.com;
return 301 https://$host$request_uri;
}మీకు పూర్తి నమ్మకం ఉన్నప్పుడు మాత్రమే Strict-Transport-Security ను జోడించండి. add_header Strict-Transport-Security "max-age=63072000; includeSubDomains" always; header ఆ hostname కోసం plain HTTP ను రెండు సంవత్సరాలపాటు నిరాకరించమని browsers కు చెబుతుంది. Browsers ఈ నియమాన్ని తమ స్వంత cache నుంచి అమలు చేస్తాయి. అందువల్ల తరువాత header ను తొలగించినా ఈ నియమం రద్దు కాదు. ముందుగా కొన్ని గంటల max-age తో ప్రారంభించండి. ప్రతి subdomain నిజంగా HTTPS పై ఉందని నిర్ధారించండి. తరువాత వ్యవధిని పెంచండి.
FAQ
HTTP మరియు HTTPS మధ్య తేడా ఏమిటి?
HTTPS అనేది TLS (transport layer security) session లో పంపే HTTP. Methods మరియు status codes ఒకేలా ఉంటాయి. మారేది ఏమిటంటే client మరియు TLS ను terminate చేసే endpoint మధ్య bytes encrypted గా ఉంటాయి. Default port 80 నుంచి 443కు మారుతుంది. మొదటి HTTP byte పంపే ముందు TLS handshake పూర్తవుతుంది. అందువల్ల certificate failure ఎప్పుడూ status code ను ఉత్పత్తి చేయదు. అందుకే browser certificate warning 403 వంటి సంఖ్యకు బదులుగా NET::ERR_CERT_COMMON_NAME_INVALID వంటి error name ను చూపిస్తుంది.
నా site 502 Bad Gateway ను ఎందుకు return చేస్తుంది?
nginx నుంచి వచ్చే 502 అంటే nginx తాను proxy చేసే upstream నుంచి ఉపయోగించగల response పొందలేకపోయిందని అర్థం. Visitor request సరిగానే ఉంది, కానీ nginx వెనుక ఉన్న ఏదో భాగంలో సమస్య ఉంది. /var/log/nginx/error.log ను చదవండి. connect() failed (111: Connection refused) while connecting to upstream అంటే proxy_pass లో పేర్కొన్న address మరియు port పై ఏదీ listening చేయడం లేదని అర్థం. కాబట్టి application నడుస్తోందో, మీరు ఆశించిన address పై bind అయిందో తనిఖీ చేయండి. no live upstreams while connecting to upstream అంటే repeated failures తర్వాత upstream block లోని ప్రతి server down గా గుర్తించబడిందని అర్థం. దీనిని 504 Gateway Timeout తో పోల్చండి. 504 Gateway Timeout అంటే upstream తో connection proxy_connect_timeout లోపు పూర్తయ్యే వరకు లేదా response proxy_read_timeout లోపు వచ్చే వరకు వేచి ఉండగా nginx timeout అయిందని అర్థం.
ప్రతి visitor కోసం నా access log ఒకే IP address ను ఎందుకు చూపిస్తుంది?
ఎందుకంటే $remote_addr TCP connection ను తెరిచిన address ను record చేస్తుంది. Reverse proxy లేదా content delivery network వెనుక ఉన్నప్పుడు ఆ address proxyదే అవుతుంది. Visitor address బదులుగా X-Forwarded-For header లో వస్తుంది. Proxyపై proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; ను set చేయండి. తరువాత receiving nginx పై set_real_ip_from ను proxy address range కు set చేసి, real_ip_header X-Forwarded-For; ను configure చేయండి. మీరు నియంత్రించే ranges ను మాత్రమే జాబితా చేయండి. ఈ header ను ఏ client అయినా పంపగల text కాబట్టి, మొత్తం internet నుంచి దాన్ని trust చేస్తే visitor log చేసే address ను, rate limit వర్తించే address ను తానే ఎంచుకోగలడు.
HTTP/2 లేదా HTTP/3 ను enable చేయాలా?
TLS ఇప్పటికే ఉన్న site పై HTTP/2 ను enable చేయడం ప్రయోజనకరం. దీనికి ఒక directive చాలు. అలాగే అనేక చిన్న files ఉన్న page ను slow చేసే ప్రతి-connection request limit తొలగిపోతుంది. HTTP/3 ద్వారా వచ్చే ప్రయోజనం తక్కువగా ఉండవచ్చు మరియు అది ఖచ్చితంగా ఉండదు. దీనికి సాధారణంగా 443 అయిన open UDP port, అలాగే QUIC support ఉన్న proxy build అవసరం. Browsers సాధారణంగా ముందరి response లో Alt-Svc header కనిపించిన తర్వాత లేదా h3 ను పేర్కొనే HTTPS DNS record ఉన్నప్పుడు మాత్రమే HTTP/3కు మారతాయి. కాబట్టి వాటిలో ఏదీ లేకపోతే, మీ listen line ఏమి చెబుతున్నా మార్పు ఉండదు. సందర్శకులు వాస్తవంగా ఏ protocol ను negotiate చేస్తున్నారో కొలవడానికి మీ log format కు $server_protocol ను జోడించండి. తరువాత దానిపై సమయం వెచ్చించాలా నిర్ణయించండి.
File ఉన్నప్పటికీ 403 Forbidden అంటే ఏమిటి?
Static site లో 403 సాధారణంగా HTTP rule సమస్య కాదు; అది filesystem permission సమస్య. /var/log/nginx/error.log లో open() ... failed (13: Permission denied) అంటే nginx worker user ఆ file ను read చేయలేకపోతున్నాడని అర్థం. చాలా సందర్భాల్లో file mode తప్పుగా ఉండటం వల్ల కాదు, parent directoryలో ఇతరులకు execute permission లేకపోవడం వల్ల ఇది జరుగుతుంది. directory index of ... is forbidden అంటే request index file లేని directoryకి resolve అయిందని అర్థం. అదే సమయంలో autoindex off లో ఉంటుంది. సరిపోలే location block లో explicit deny rule ఉన్నా 403 return అవుతుంది. కాబట్టి error log లో ఏమీ కనిపించనప్పుడు ఆ block ను చదవండి.