SSD Nodes Learn Hosting plans →

కొత్త VPS కు సర్వర్‌ను ఎలా తరలించాలి

కొత్త VPS కు live server తరలింపును సురక్షితంగా చేయండి: inventory, clone కాకుండా rebuild, database dump, ముందే DNS TTL తగ్గింపు, verify చేసి switch చేయడం తెలుసుకోండి.

కొత్త VPS కు సర్వర్‌ను ముందస్తు పరీక్షించిన cutover విధానంలో తరలించడం

సర్వర్‌ను కొత్త VPS కు తరలించేటప్పుడు, ఈ మార్పును కేవలం కాపీ ప్రక్రియగా కాకుండా ముందుగా పరీక్షించిన cutover గా నిర్వహించండి. కొత్త సిస్టమ్‌ను మొదటి నుంచి నిర్మించండి. డేటాను రెండుసార్లు సమకాలీకరించండి. DNS ను మార్చే ముందు కొత్త సిస్టమ్ తన స్వంత IP address పై సరిగ్గా పనిచేస్తుందని నిర్ధారించండి. తరువాత records ను మార్చండి. మీరు పూర్తిగా నిర్ధారించుకునే వరకు పాత సిస్టమ్‌ను నడుస్తూనే ఉంచండి. Bytes ను కాపీ చేయడం సులభమైన భాగం. చర్యల క్రమమే ఈ మార్పు సమస్యలేకుండా పూర్తవుతుందా లేదా ఖరీదైన సమస్యగా మారుతుందా అన్నది నిర్ణయిస్తుంది.

ఈ guide ఒక web application, database మరియు TLS (transport layer security) certificate నడుపుతున్న ఒక Linux server ను కవర్ చేస్తుంది. చాలా single-server setups కు ఇది సరిపోతుంది. ఇందులో రెండు hosts ఉంటాయి. అందువల్ల ప్రతి ఉదాహరణలో అది ఏ host పై నడుస్తుందో comment లో పేర్కొంటుంది. Addresses documentation ranges నుంచి తీసుకున్నవి: 198.51.100.10 పాత server, 203.0.113.20 కొత్త server.

మీరు ప్రారంభించే ముందు మొత్తం runbook చదవండి. మొదటి దశ అయిన DNS TTL తగ్గింపు, మీరు నిజంగా ముఖ్యంగా భావించే దశకు కొన్ని రోజుల ముందే చేయాలి.

ఏదైనా నిర్మించే ముందు ఇన్వెంటరీ తీసుకోండి

మీరు వివరాలు నమోదు చేయని server ను పునర్నిర్మించలేరు. పాత server ఏమి చేస్తుందో రాయడానికి ఒక గంట కేటాయించండి. ఎందుకంటే migration తర్వాత విఫలమయ్యేది ఎవరూ గుర్తుంచుకోని అంశమే: cron job, firewall మినహాయింపు లేదా application directory వెలుపల ఉన్న environment file.

పాత server పై వీటిని అమలు చేసి, కొత్త server నుంచి చదవగలిగే చోట output ను భద్రపరచండి.

# old server: packages you asked for, not the dependencies they pulled in
apt-mark showmanual > ~/inv-packages.txt

# old server: what runs now, and what starts at boot
systemctl list-units --type=service --state=running --no-pager > ~/inv-services.txt
systemctl list-unit-files --state=enabled --no-pager >> ~/inv-services.txt
systemctl list-timers --all --no-pager > ~/inv-timers.txt

# old server: what is listening, on which address and port
sudo ss -tulpn > ~/inv-ports.txt

# old server: human accounts, skipping the system ones
awk -F: '$3 >= 1000 && $3 < 65534 {print $1, $3, $6, $7}' /etc/passwd

Dependencies గా వచ్చిన ప్రతిదాన్ని తొలగించి చూపుతుంది కాబట్టి apt-mark showmanual జాబితా ఉపయోగకరంగా ఉంటుంది. ఐదు సంవత్సరాల పాత server పై పూర్తి dpkg --get-selections అమలు చేస్తే రెండు వేల lines వస్తాయి. కానీ అవి ఎందుకు అవసరమో తెలియజేయవు.

Scheduled పనులు రెండు చోట్ల ఉండవచ్చు. కాబట్టి రెండింటినీ పరిశీలించండి. నెలకు ఒకసారి మాత్రమే నడిచే job ను migration తర్వాత ఆరు వారాలకు గుర్తించే అవకాశం ఉంటుంది.

# old server: per-user crontabs, then the system drop-ins
for u in $(cut -d: -f1 /etc/passwd); do sudo crontab -lu "$u" 2>/dev/null | sed "s/^/$u: /"; done
sudo ls -la /etc/cron.d /etc/cron.daily /etc/cron.hourly

తరువాత సాధారణ files కాని అంశాలను పరిశీలించండి: firewall rules, certificates, databases మరియు మీరు వాస్తవంగా ఎంత data ను తరలిస్తున్నారో.

# old server
sudo ufw status verbose        # or: sudo nft list ruleset
sudo certbot certificates
sudo -u postgres psql -c '\l'  # or: sudo mysql -e 'SHOW DATABASES;'
sudo du -xh --max-depth=1 / | sort -h

certbot certificates ప్రతి certificate పేరు, అది వర్తించే domains, expiry date మరియు disk పై ఉన్న files paths ను ముద్రిస్తుంది. ఆ output మీ TLS checklist. du -x ఒకే filesystem లోనే ఉంటుంది. అందువల్ల mounted backup volume లోకి వెళ్లి, వాస్తవ పరిమాణం కంటే పది రెట్లు ఎక్కువ సంఖ్యను చూపదు.

Server వెలుపల ఉండే రెండు అంశాలను ప్రతిసారీ మర్చిపోతారు. మొదటిది, మీ server IP address ను allowlist చేసే ఏదైనా third party: payment gateway, managed database, SMTP relay లేదా partner API. కొత్త server కు కొత్త address ఉంటుంది. కాబట్టి cutover కు ముందు allowlists లో కొత్త IP ను చేర్చాలి, తరువాత కాదు. రెండవది, మీరు స్వయంగా సృష్టించని DNS records. ఉదాహరణకు MX record లేదా text లో పాత IP ను పేర్కొనే SPF record.

పాత root filesystem ను clone చేయకుండా మళ్లీ నిర్మించడానికి కారణం

మొత్తం root filesystem ను కొత్త VPS కు clone చేయడం వేగంగా కనిపిస్తుంది. అది నిజంగానే వేగంగా ఉంటుంది, సమస్యలు మొదలయ్యే వరకు. సంవత్సరాలుగా production లో ఉన్న root filesystem లో ఎవరూ documentation చేయని చేతితో మార్చిన config, ప్రస్తుతం లేని repository నుంచి వచ్చిన packages, అలాగే పాత platform యొక్క virtual hardware కోసం రూపొందించిన boot setup ఉంటాయి. వీటన్నింటినీ import చేస్తే, migration చేయడానికి కారణమైన సమస్య కూడా మీతో పాటు వస్తుంది.

మొదటి రోజున rebuilding నెమ్మదిగా ఉంటుంది. ఆ తర్వాత ప్రతి రోజూ తక్కువ ఖర్చుతో ఉంటుంది. ప్రస్తుత release ను install చేసి, మీ base hardening అమలు చేయండి. తరువాత data మాత్రమే copy చేయండి: application directory, site configs, database dump, certificates, user uploads. మీరు వివరించలేని ఏదీ కొత్త సిస్టమ్‌కు తీసుకురావద్దు. కొత్త VPS పై మొదటి పది నిమిషాల్లో చేసే పనులతో ప్రారంభించండి: కొత్త VPS పై మొదటి పది నిమిషాలు. తరువాత inventory లోని services ను ఒక్కొక్కటిగా add చేయండి. తదుపరి service ను add చేసే ముందు ప్రతి service సరిగ్గా పనిచేస్తోందని నిర్ధారించండి.

ఇమేజ్ లేదా స్నాప్‌షాట్ రీస్టోర్ ఎప్పుడు సరైన నిర్ణయం అవుతుంది

మళ్లీ నిర్మించడానికి (rebuilding) సంబంధించి ఒక నిజాయితీ గల మినహాయింపు ఉంది. పాత సర్వర్ బూట్ కానప్పుడు, లేదా ఇకపై సోర్స్ కోడ్ నుంచి నిర్మించడం సాధ్యం కాని అప్లికేషన్ ఉన్నప్పుడు, ప్రొవైడర్ ఇమేజ్ లేదా స్నాప్‌షాట్ రీస్టోర్ అనేది ఆచరణాత్మక పరిష్కారం. ఇమేజ్ పోర్టబిలిటీ అనేది ప్లాట్‌ఫారమ్‌పై ఆధారపడి ఉంటుంది: ఉదాహరణకు, AWS తన ఎగుమతి పరిమితులకు లోబడి, చాలా EC2 ఇన్‌స్టాన్స్‌లను Citrix Xen, Microsoft Hyper-V, లేదా VMware vSphere కు ఎగుమతి చేయడానికి మద్దతు ఇస్తుంది. రీస్టోర్‌పై ఆధారపడే ముందు సోర్స్ ప్లాట్‌ఫారమ్ యొక్క ఎగుమతి మద్దతును మరియు టార్గెట్ యొక్క డిస్క్ ఫార్మాట్, వర్చువల్ డివైజ్ మరియు నెట్‌వర్క్ అవసరాలను తనిఖీ చేయండి.

రన్నింగ్‌లో ఉన్న బాక్స్ యొక్క స్నాప్‌షాట్ కూడా, స్నాప్‌షాట్ ప్రక్రియ డేటాబేస్‌తో సమన్వయం చెందకపోతే లేదా దాని ఫైళ్లు మరియు లాగ్‌లను స్థిరమైన సెట్‌గా క్యాప్చర్ చేయకపోతే, లైవ్ డేటాబేస్ యొక్క ఇతర ఫైల్-స్థాయి కాపీల మాదిరిగానే అదే స్థిరత్వ సమస్యను కలిగి ఉంటుంది. ఇమేజ్ రీస్టోర్‌ను మైగ్రేషన్ ప్లాన్‌గా కాకుండా రికవరీ మార్గంగా పరిగణించండి, మరియు మీరు దానిపై ఒక ప్రణాళికను రూపొందించే ముందు స్నాప్‌షాట్ మరియు బ్యాకప్ ఎందుకు ఒకటే కాదు అనే అంశాన్ని చదవండి.

ఫైళ్లు ఎలా బదిలీ అవుతాయి: SSH ద్వారా rsync

పాత సర్వర్ నుండి rsync కమాండ్‌ను రన్ చేసి, కొత్త సర్వర్‌కు డేటాను పంపండి. పాత సర్వర్‌లో ఇప్పటికే డేటా ఉండటం మరియు అది sudo కింద అన్ని ఫైళ్లను చదవగలగడం వల్ల, డేటాను పంపడం (pushing) సాధారణంగా సులభంగా ఉంటుంది. ఫైల్ యాజమాన్య హక్కులు (ownership) మరియు ప్రత్యేక extended attributes మారకుండా ఉండాలంటే, అవతలి వైపున ఉన్న rsync కూడా root యూజర్‌గా రన్ అవ్వాలి; ఈ ఉదాహరణలకు కొత్త సర్వర్‌లో root SSH యాక్సెస్ అవసరం.

# old server: dry run first, and read what it says it will do
sudo rsync -aHAX --dry-run --itemize-changes \
  -e 'ssh -i /root/.ssh/id_ed25519' \
  /srv/app/ root@203.0.113.20:/srv/app/

# old server: the real bulk pass
sudo rsync -aHAX --info=progress2 \
  -e 'ssh -i /root/.ssh/id_ed25519' \
  /srv/app/ root@203.0.113.20:/srv/app/

ఇక్కడ వాడే flags చాలా ముఖ్యం. -a ఫైల్ అనుమతులు (permissions), టైమ్‌స్టాంపులు, సింబాలిక్ లింకులు మరియు యాజమాన్య హక్కులను అలాగే ఉంచుతుంది. -H హార్డ్ లింకులను విడి ఫైళ్లుగా కాకుండా, హార్డ్ లింకులుగానే ఉంచుతుంది. -A POSIX ACLలను (access control lists) మరియు -X extended attributesను కాపీ చేస్తుంది. ఈ చివరి రెండు లేకపోతే, ఫైళ్లు ఒకేలా కనిపించినా వాటి ప్రవర్తన మారవచ్చు, ఎందుకంటే SELinux లేబుల్స్ మరియు ACLలు extended attributesలోనే ఉంటాయి.

రెండు చిన్న విషయాలు తరచుగా సమస్యలకు దారితీస్తాయి.

ట్రైలింగ్ స్లాష్ (trailing slash) డేటా ఎక్కడ చేరుతుందో నిర్ణయిస్తుంది. /srv/app/ అంటే ఆ డైరెక్టరీలోని కంటెంట్ అని అర్థం. /srv/app అంటే ఆ డైరెక్టరీనే అని అర్థం. ఇది పొరపాటు జరిగితే, కొత్త సర్వర్‌లో /srv/app/app ఏర్పడుతుంది. అప్పుడు అప్లికేషన్ స్టార్ట్ అయిన తర్వాత ఫైళ్లు లేవని చూపిస్తుంది, ఎందుకంటే ఫైల్ పాత్‌లు ఒక స్థాయి తక్కువలో ఉంటాయి.

sudo కింద, టిల్డే (tilde) అంటే root యొక్క హోమ్ డైరెక్టరీ. sudo rsync లోపల -e 'ssh -i ~/.ssh/id_ed25519' అని రాస్తే, అది మీ సొంత హోమ్ డైరెక్టరీలో కాకుండా /root/.ssh లో కీ కోసం వెతుకుతుంది. కీ అక్కడ లేకపోతే, SSH Permission denied (publickey) అని చూపిస్తుంది, rsync rsync: connection unexpectedly closed అని ప్రింట్ చేసి ఆగిపోతుంది. కీ పాత్‌ను పూర్తిగా రాయండి. పాత్ సరిచేసినా కూడా ఆ అథెంటికేషన్ మెసేజ్ వస్తూనే ఉంటే, publickey ఫెయిల్యూర్ రావడానికి కొన్ని కారణాలు ఉంటాయి మరియు కొత్త సర్వర్‌లో డైరెక్టరీ పర్మిషన్లను తనిఖీ చేయడం తదుపరి దశ.

యాజమాన్య హక్కుల విషయంలో ఒక నిర్ణయం తీసుకోవాలి. rootగా రన్ చేస్తున్నప్పుడు, rsync డిఫాల్ట్‌గా owner మరియు groupలను పేరు ఆధారంగా మ్యాప్ చేస్తుంది. కాబట్టి పాత సర్వర్‌లో www-data యాజమాన్యంలో ఉన్న ఫైల్, కొత్త సర్వర్‌లో www-data యాజమాన్యంలోకి మారుతుంది (numeric UID వేరైనా సరే). సర్వర్‌ను మళ్ళీ నిర్మిస్తున్నప్పుడు ఇదే సరైన పద్ధతి. అకౌంట్ పేర్లను మ్యాప్ చేయకుండా numeric ownership అలాగే ఉండాలంటే --numeric-ids ని జోడించండి. ఆ తర్వాత ls -ln తో ఫలితాన్ని తనిఖీ చేయండి, ఎందుకంటే అకౌంట్ లేని UID ఉన్న ఫైల్ కేవలం నంబర్‌గా మాత్రమే కనిపిస్తుంది; యాక్సెస్ మాత్రం numeric IDలు, పర్మిషన్లు మరియు ACLలపైనే ఆధారపడి ఉంటుంది.

పాత సర్వర్ ఇంకా ట్రాఫిక్‌ను సర్వ్ చేస్తున్నప్పుడే, కొన్ని రోజుల ముందే బల్క్ కాపీని రన్ చేయండి. మీకు నచ్చినన్ని సార్లు దీన్ని రిపీట్ చేయవచ్చు: rsync కేవలం మారిన ఫైళ్లను మాత్రమే పంపుతుంది, కాబట్టి రెండోసారి రన్ చేసినప్పుడు గంటల సమయం పట్టదు, కేవలం నిమిషాల్లో పూర్తవుతుంది. కట్‌ఓవర్ సమయంలో చేసే చివరి పాస్‌లో --delete ని జోడించండి, దీనివల్ల పాత సర్వర్‌లో డిలీట్ చేసిన ఫైళ్లు కొత్త సర్వర్‌లో కూడా తొలగించబడతాయి.

# old server: final pass, inside the window, after the app has stopped writing
sudo rsync -aHAX --delete --info=progress2 \
  -e 'ssh -i /root/.ssh/id_ed25519' \
  /srv/app/ root@203.0.113.20:/srv/app/

--delete వల్ల సోర్స్ సర్వర్‌లో లేని ఫైళ్లు డెస్టినేషన్ సర్వర్‌లో కూడా తొలగిపోతాయి, కాబట్టి తప్పుడు సోర్స్ పాత్ ఇచ్చి --delete వాడితే డెస్టినేషన్ డైరెక్టరీ ఖాళీ అయిపోతుంది. ప్రతిసారీ ముందుగా --dry-run తో రన్ చేసి తనిఖీ చేయండి. లాప్‌టాప్ SSH సెషన్ డిస్‌కనెక్ట్ అయితే పెద్ద ట్రాన్స్‌ఫర్లు ఆగిపోతాయి, కాబట్టి వాటిని పాత సర్వర్‌లో tmux లేదా screen లోపల స్టార్ట్ చేయండి. పాత సర్వర్ ఇంకా యూజర్లకు సేవలు అందిస్తుంటే, నెట్‌వర్క్ స్లో అవ్వకుండా ఉండటానికి --bwlimit=20M ని జోడించండి.

డేటాబేస్ తరలింపు: నేటివ్ డంప్ (Native dump)

డేటాబేస్ ఒక ఫైల్ డైరెక్టరీలా కనిపించినప్పటికీ, అది కేవలం ఫైళ్ల సమూహం కాదు. ఇది ఫైళ్లు, మెమరీలో ఉన్న స్థితి (in-memory state) మరియు రైట్-అహెడ్ లాగ్ (write-ahead log) ల కలయిక. డేటాబేస్ స్వయంగా నిర్ణయించిన సమయాల్లో మాత్రమే ఇది స్థిరంగా (consistent) ఉంటుంది. కాబట్టి, దాని సొంత సాధనాలనే ఉపయోగించండి.

PostgreSQL కి రెండు డంప్‌లు అవసరం, ఎందుకంటే రోల్స్ (roles) క్లస్టర్ మొత్తానికి వర్తిస్తాయి మరియు pg_dump వాటిని కలిగి ఉండదు:

# old server
sudo -u postgres pg_dumpall --globals-only -f /var/backups/globals.sql
sudo -u postgres pg_dump -Fc -f /var/backups/appdb.dump appdb
# new server: restore in this order
sudo -u postgres psql -f /var/backups/globals.sql
sudo -u postgres createdb -O appuser appdb
sudo -u postgres pg_restore -d appdb --no-owner /var/backups/appdb.dump

globals.sql ని విస్మరిస్తే, అన్ని టేబుల్స్ పునరుద్ధరించబడతాయి కానీ ఏ అప్లికేషన్ రోల్ వాటిని చదవలేదు. ఎందుకంటే GRANT స్టేట్‌మెంట్‌లు లేని యూజర్‌ను సూచిస్తాయి. -Fc కస్టమ్ ఆర్కైవ్ ఫార్మాట్‌ను వ్రాస్తుంది, దీనిని pg_restore మాత్రమే చదవగలదు మరియు ఇది తర్వాత ఎంచుకున్న టేబుల్స్‌ను మాత్రమే పునరుద్ధరించడానికి అనుమతిస్తుంది. ఒకే మేజర్ వెర్షన్ లేదా కొత్త వెర్షన్‌లోకి పునరుద్ధరించండి. పాత వెర్షన్‌కు వెళ్లడం (downgrade) ఖచ్చితంగా పనిచేస్తుందని చెప్పలేము, అది ఆ రెండు వెర్షన్లపై ఆధారపడి ఉంటుంది. ఆర్కైవ్ ఫార్మాట్ అది చదవగలిగే దానికంటే కొత్తగా ఉన్నప్పుడు మాత్రమే pg_restore, unsupported version (1.16) in file header తో ఆర్కైవ్‌ను తిరస్కరిస్తుంది. PostgreSQL 16 యొక్క pg_restore, 17 లేదా 18 వెర్షన్ డంప్‌ను చూసినప్పుడు ఇలాగే జరుగుతుంది. PostgreSQL 17 మరియు 18 ఒకే ఆర్కైవ్ ఫార్మాట్ వెర్షన్ (1.16) ను వాడుతాయి, కాబట్టి 17 యొక్క pg_restore, 18 యొక్క డంప్‌ను అంగీకరిస్తుంది. ఇది పునరుద్ధరణను ప్రారంభిస్తుంది, పాత సర్వర్ తిరస్కరించే అంశం వచ్చే వరకు టేబుల్స్‌ను సృష్టించి డేటాను లోడ్ చేస్తుంది (నవంబర్ 13, 2026 నాటికి 18.7 ప్రస్తుత రిలీజ్). మీరు 18 నుంచి 17 కి వెళ్లాల్సి వస్తే, ముందుగా ఒక తాత్కాలిక డేటాబేస్‌లోకి పునరుద్ధరించి, పాత సర్వర్‌కు అర్థం కాని సింటాక్స్‌ను తొలగించడానికి డంప్ ఫైల్‌ను మాన్యువల్‌గా ఎడిట్ చేయండి.

MySQL మరియు MariaDB ఒకే కమాండ్‌ను ఉపయోగిస్తాయి. దీని ఆప్షన్లను స్పష్టంగా పేర్కొనండి, ఎందుకంటే వాటిలో చాలా వరకు డిఫాల్ట్‌గా ఉండవు:

# old server
sudo mysqldump --single-transaction --routines --triggers --events \
  --databases appdb > /var/backups/appdb.sql
# new server
sudo mysql < /var/backups/appdb.sql

--single-transaction, InnoDB టేబుల్స్ కోసం రైటర్లను బ్లాక్ చేయకుండా స్థిరమైన స్నాప్‌షాట్‌ను తీసుకుంటుంది. అదే డేటాబేస్‌లోని MyISAM టేబుల్స్ కోసం ఇటువంటి హామీ ఉండదు, కాబట్టి డంప్‌ను నమ్మే ముందు మీ స్టోరేజ్ ఇంజిన్‌లను తనిఖీ చేయండి. --routines మరియు --events డిఫాల్ట్‌గా ఆఫ్ చేయబడి ఉంటాయి, అంటే సాధారణ డంప్ మీ డేటాను పునరుద్ధరిస్తుంది కానీ స్టోర్డ్ ప్రొసీజర్లు మరియు షెడ్యూల్డ్ ఈవెంట్లను వదిలేస్తుంది. --triggers, MySQL మరియు MariaDB రెండింటిలోనూ డిఫాల్ట్‌గా ఆన్‌లో ఉంటుంది; దీనిని పేర్కొనడం వల్ల నష్టం లేదు మరియు ఇది ఉద్దేశాన్ని నమోదు చేస్తుంది. డేటాబేస్ యూజర్లు మరియు వారి అనుమతులు mysql సిస్టమ్ డేటాబేస్‌లో ఉంటాయి, వీటిని --databases appdb డంప్ తాకదు, కాబట్టి కొత్త సర్వర్‌లో CREATE USER మరియు GRANT తో వాటిని మళ్లీ సృష్టించండి. MariaDB లో ఈ సాధనం పేరు mariadb-dump. MariaDB 11.0 నుండి mysqldump పేరు కేవలం ఒక డిప్రికేటెడ్ సింబాలిక్ లింక్ మాత్రమే, మరియు mariadb Docker Official Image లో ఇది అసలు ఉండదు. కాబట్టి MariaDB 11 లేదా అంతకంటే ఎక్కువ వెర్షన్లలో అదే ఆప్షన్లతో mariadb-dump ని రన్ చేసి, mariadb తో పునరుద్ధరించండి (అక్టోబర్ 2026 నాటికి తనిఖీ చేయబడింది).

SQLite ఒకే ఫైల్‌గా ఉంటుంది, అప్లికేషన్ వ్రాస్తున్నప్పుడు దానిని కాపీ చేస్తే ఫైల్ పాడయ్యే అవకాశం ఉంది. దీనికి సురక్షితమైన మార్గం ఇక్కడ ఉంది:

# old server
sqlite3 /var/lib/app/app.db ".backup '/var/backups/app.db'"

ఇంజిన్ ఏదైనా సరే, డంప్‌ను నమ్మే ముందు దానిని తనిఖీ చేయండి. డిస్క్ నిండిపోవడం వల్ల మధ్యలోనే ఆగిపోయిన డంప్ పాక్షిక పునరుద్ధరణకు దారితీయవచ్చు. పునరుద్ధరణ ప్రక్రియ అసంపూర్ణమైన స్టేట్‌మెంట్ లేదా ఆర్కైవ్ డేటాను చేరుకున్నప్పుడు మాత్రమే లోపాలు కనిపిస్తాయి.

# old server: a complete mysqldump ends with a line reading "-- Dump completed on ..."
tail -n 3 /var/backups/appdb.sql

# new server: after restore, count rows in a table whose size you know
sudo mysql -e 'SELECT COUNT(*) FROM appdb.orders;'

నడుస్తున్న database పై rsync ఎందుకు ఉపయోగించలేరు

rsync ఫైల్‌ను ఒక్కొక్కటిగా copy చేస్తుంది. నడుస్తున్న database ఒకేసారి అనేక ఫైళ్లలో writes చేస్తుంది. అందువల్ల rsync చివరి ఫైల్‌కు చేరే సమయానికి మొదటి ఫైల్ ఇప్పటికే పాతదై ఉంటుంది. ఈ copyలో వేర్వేరు సమయాలకు చెందిన pages ఉంటాయి. databaseలో అలాంటి state ఎప్పుడూ ఉండదు. ఫలితంగా server ప్రారంభం కావడానికి నిరాకరించవచ్చు. లేదా మరింత ప్రమాదకరంగా, server ప్రారంభమై ఒక వారం పాటు సరైన సమాధానాలు అందించవచ్చు. తరువాత ఏదైనా query దెబ్బతిన్న pageను చేరినప్పుడు విఫలమవుతుంది. మధ్యలో ఎలాంటి warning ఉండదు.

ఫైళ్లను స్వయంగా తరలించడానికి రెండు సురక్షితమైన మార్గాలు ఉన్నాయి. databaseను stop చేసి, copy చేసి, మళ్లీ start చేయండి. ఇది సరైనది, సరళమైనది. అయితే downtime copy పూర్తయ్యేంత సమయం ఉంటుంది. లేదా నడుస్తున్న server యొక్క physical copy కోసం రూపొందించిన toolను ఉపయోగించండి. PostgreSQL కోసం అది pg_basebackup. ఇది serverతో సమన్వయం చేసి copy consistentగా ఉండేలా చేస్తుంది:

# new server: pull a physical copy from the old one
pg_basebackup -h 198.51.100.10 -U replicator -D /var/lib/postgresql/16/main -X stream -P

దీనికి REPLICATION attribute ఉన్న role మరియు పాత serverలో సరిపోయే pg_hba.conf entry అవసరం. అందువల్ల dumpతో పోలిస్తే దీనికి ఎక్కువ setup అవసరం. dump మరియు restore మీ maintenance windowలో పూర్తికానింత పెద్ద database ఉన్నప్పుడు ఇది ఉపయోగకరంగా ఉంటుంది. సాధారణ single-server migration కోసం dump ఉత్తమమైన ఎంపిక.

Cutover కు ముందే certificates ను పునర్నిర్మించండి, తర్వాత కాదు

TLS certificate అనేది IP అడ్రస్‌కు కాకుండా డొమైన్ పేరుకు అనుసంధానించబడి ఉంటుంది, కాబట్టి certificate ఫైల్ ఎటువంటి ఇబ్బంది లేకుండా మారుతుంది. అయితే, renewal ప్రక్రియ అంత సులభంగా మారదు. HTTP-01 పద్ధతిలో, certificate authority (CA) అనేది సర్టిఫై చేయబడిన పేరుతో port 80 ద్వారా challenge response ను అడుగుతుంది; DNS మారకముందే, పాత సర్వర్ ఆ response ను అందించాలి లేదా validation అభ్యర్థనలను కొత్త సర్వర్‌కు పంపాలి, అప్పుడే renewal విజయవంతమవుతుంది.

మొదటి ఎంపిక ఏమిటంటే, ఇప్పటికే ఉన్న certificates మరియు వాటి renewal స్థితిని కాపీ చేయడం. ఏ సర్వర్‌లో ఉన్నా సరే, వాటి గడువు తేదీ వరకు అవి చెల్లుబాటు అవుతాయి.

# old server
sudo rsync -aHAX -e 'ssh -i /root/.ssh/id_ed25519' \
  /etc/letsencrypt/ root@203.0.113.20:/etc/letsencrypt/

/etc/letsencrypt/renewal/ లోని ప్రతి ఫైల్ ఆ certificate ను జారీ చేసిన authenticator plugin పేరును కలిగి ఉంటుంది, కాబట్టి కొత్త సర్వర్‌లో కూడా అదే plugin ను ఇన్‌స్టాల్ చేయండి (ఉదాహరణకు python3-certbot-nginx), లేకపోతే తెలియని authenticator గురించి వచ్చే సందేశంతో మొదటి renewal విఫలమవుతుంది. మీరు దానిపై ఆధారపడే ముందు renewal పనిచేస్తుందో లేదో పరీక్షించండి:

# new server, after DNS has moved or validation forwarding is configured
sudo certbot renew --dry-run

రెండవ ఎంపిక ఏమిటంటే, DNS-01 challenge ఉపయోగించి కొత్త సర్వర్‌లో తాజా certificate ను జారీ చేయడం. ఇది TXT record ద్వారా నియంత్రణను నిరూపిస్తుంది మరియు port 80 తో సంబంధం లేకుండా పనిచేస్తుంది. మైగ్రేషన్‌కు ముందే, అంటే డొమైన్ పేరు ఇంకా పాత సర్వర్‌కే resolve అవుతున్నప్పుడు కూడా ఇది పనిచేస్తుంది, కాబట్టి మీరు మీ DNS ప్రొవైడర్‌ను ఆటోమేట్ చేయగలిగితే ఇది ఉత్తమమైన ఎంపిక. DNS-01 challenge తో certificates జారీ చేయడం విభాగంలో plugin మరియు credential సెటప్ గురించి వివరించబడింది.

పాత సర్వర్ /.well-known/acme-challenge/ అభ్యర్థనలను కొత్త సర్వర్‌కు పాయింట్ చేసే వేరొక public hostname కు మళ్లించినట్లయితే (redirect), సైట్ యొక్క DNS మారకముందే HTTP-01 కూడా పనిచేస్తుంది. Let's Encrypt గరిష్టంగా 10 redirects వరకు అనుసరిస్తుంది, దీని కోసం port 80 లేదా 443 పై HTTP లేదా HTTPS ను ఉపయోగిస్తుంది.

ఏ పద్ధతిని ఎంచుకున్నా, DNS మార్చకుండానే కొత్త సర్వర్ ఏమి అందిస్తుందో తనిఖీ చేయండి:

# your laptop
echo | openssl s_client -connect 203.0.113.20:443 -servername example.com 2>/dev/null \
  | openssl x509 -noout -subject -dates -issuer

-servername అనేది SNI (server name indication) ను పంపుతుంది, దీనివల్ల వెబ్ సర్వర్ సరైన virtual host ను ఎంచుకోగలదు. దీన్ని వదిలేస్తే, ఆ IP కి సంబంధించిన default certificate వస్తుంది మరియు అది నిజమైన సమస్యలా అనిపించే mismatch ను చూపిస్తుంది, కానీ అది సమస్య కాదు.

Cutover కు కొన్ని రోజుల ముందే DNS TTL ను తగ్గించండి

DNS విషయంలో జాగ్రత్తగా వలస (migration) చేపట్టినా పొరపాట్లు జరగవచ్చు, ఎందుకంటే ఇందులో జాప్యం సహజంగా ఉంటుంది. కట్‌ఓవర్ రోజున TTL తగ్గించడం వల్ల ఇప్పటికే cache లో ఉన్న సమాచారం యొక్క కాలపరిమితి తగ్గదు. మీ A record ను cache చేసిన resolver, దానికి అందిన TTL (time to live) పూర్తయ్యే వరకు పాత IP నే చూపిస్తుంది. పది నిమిషాల క్రితం పాత విలువతో cache చేసిన record కు, ఇప్పుడు TTL తగ్గించినా ఎటువంటి ఉపయోగం ఉండదు; అది పాత TTL ముగిసే వరకు పాత విలువనే ఉంచుకుంటుంది, ఆ తర్వాతే కొత్త, తక్కువ విలువను స్వీకరిస్తుంది. కాబట్టి, కట్‌ఓవర్ కు కనీసం ఒక పాత-TTL కాలపరిమితికి ముందే TTL ను తగ్గించండి. ఒక రోజు ముందుగా చేయడం సురక్షితం. ఈ ప్రక్రియ మీకు కొత్త అయితే, records, resolvers మరియు caching ల గురించిన వివరణ మీకు నేపథ్య సమాచారాన్ని అందిస్తుంది.

కింద ఉన్న సంఖ్యలు TTL నుండి లెక్కించినవి, ఇవి కొలతలు కావు.

చార్ట్How long a stale IP can survive, by record TTL
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "label": "TTL 3600 s",
    "ttl_seconds": 3600,
    "worst_case_stale_minutes": 60
  },
  {
    "label": "TTL 900 s",
    "ttl_seconds": 900,
    "worst_case_stale_minutes": 15
  },
  {
    "label": "TTL 300 s (lowered for cutover)",
    "ttl_seconds": 300,
    "worst_case_stale_minutes": 5
  },
  {
    "label": "TTL 60 s (short window)",
    "ttl_seconds": 60,
    "worst_case_stale_minutes": 1
  }
]

3600 సెకన్ల TTL తో ప్రచురించబడిన A record, మీరు మార్పు చేసిన తర్వాత కూడా 60 నిమిషాల వరకు వినియోగదారులను పాత IP కే పంపవచ్చు. దీనిని 300 సెకన్లకు తగ్గిస్తే, ఆ గరిష్ట సమయం 5 నిమిషాలకు తగ్గుతుంది. ఈ గణాంకాలను ఒక హామీగా కాకుండా కనీస ప్రమాణంగా పరిగణించండి. కొన్ని resolvers సొంతంగా కనీస TTL ను కలిగి ఉండి, అంతకంటే తక్కువ ఉన్న విలువలను విస్మరిస్తాయి. అలాగే, కొన్ని అప్లికేషన్లు అడ్రస్‌ను ప్రాసెస్ జీవితకాలం వరకు cache లో ఉంచుకుంటాయి, కాబట్టి మీ మార్పుకు ముందే ప్రారంభమైన క్లయింట్, అది రీస్టార్ట్ అయ్యే వరకు కొత్త అడ్రస్‌ను చూడకపోవచ్చు.

తక్కువ TTL అమలవుతుందో లేదో తనిఖీ చేసేటప్పుడు, మీ స్వంత cache ను కాకుండా authoritative సమాధానాన్ని చూడండి:

# your laptop: ask the zone's own nameserver, so no cache is involved
dig +short NS example.com
dig +noall +answer @$(dig +short NS example.com | head -n1) example.com A

ఆ సమాధానం లైన్‌లోని రెండవ ఫీల్డ్ సెకన్లలో ఉన్న TTL. ఆ తర్వాత ప్రజలు తరచుగా మర్చిపోయే records ను తనిఖీ చేయండి: పాత సర్వర్‌కు IPv6 ఉంటే AAAA record, www పేరు CNAME కాకుండా విడిగా A record గా ఉంటే అది, సర్వర్‌ను సూచించే ఏదైనా MX record, పాత IP ని కలిగి ఉన్న SPF record, మరియు కొత్త అడ్రస్‌పై ఉన్న reverse DNS (PTR) record. సర్వర్ మెయిల్ పంపుతుంటే, కట్‌ఓవర్ కు ముందే మీ ప్రొవైడర్ కంట్రోల్ ప్యానెల్ ద్వారా PTR ను సెట్ చేయండి. ఎందుకంటే మెయిల్ స్వీకరించే సర్వర్లు దీనిని తనిఖీ చేస్తాయి, PTR లేకపోతే మిగిలినవన్నీ సరిగ్గా ఉన్నా గంటల తర్వాత మెయిల్ తిరస్కరించబడుతుంది.

DNS ను మార్చే ముందు కొత్త server ను దాని IPపై ధృవీకరించండి

DNS ఇప్పటికీ పాత server వైపు చూపుతున్నప్పటికీ, కొత్త server పై మొత్తం అప్లికేషన్‌ను పరీక్షించవచ్చు. ఒక అభ్యర్థన కోసం name lookup ను override చేయండి:

# your laptop: force one name to the new IP, for this request only
curl -sS --resolve example.com:443:203.0.113.20 \
  -o /dev/null -w '%{http_code} %{ssl_verify_result}\n' https://example.com/

--resolve కనెక్షన్ ఎక్కడికి వెళ్తుందో మాత్రమే మారుస్తుంది. TLS certificate ను ఇప్పటికీ అసలు పేరుతోనే తనిఖీ చేస్తుంది. అందువల్ల certificate తో పాటు service కూడా సరిగ్గా పనిచేస్తోందని ఇది ధృవీకరిస్తుంది. chain ధృవీకరించబడినప్పుడు %{ssl_verify_result}, 0 ను ప్రింట్ చేస్తుంది.

బ్రౌజర్‌లో site ను క్లిక్ చేస్తూ పరీక్షించాలంటే, మీ laptop లోని /etc/hosts కు లేదా Windows లోని C:\Windows\System32\drivers\etc\hosts కు ఒక line జోడించి, మొత్తం machine కోసం name ను override చేయండి:

203.0.113.20 example.com www.example.com

తరువాత user ఉపయోగించినట్లే అప్లికేషన్‌ను పరిశీలించండి. Login చేయండి. Database నుంచి data చదివే page ను load చేయండి. Database లో data రాసే form ను submit చేయండి. File ను upload చేసి, అది disk పై సరిగ్గా చేరిందని నిర్ధారించండి. Email పంపే ఏదైనా చర్యను trigger చేసి, అది చేరిందో తనిఖీ చేయండి. కొత్త IP నుంచి outbound SMTP తరచుగా అనుకోని సమస్యలను కలిగిస్తుంది. పని పూర్తయిన వెంటనే hosts line ను తొలగించండి. దాన్ని అలాగే ఉంచితే, మిగతా అందరికీ site సరిగ్గా కనిపిస్తున్నప్పటికీ, మీరు ఒక గంట పాటు దానిని debug చేసే పరిస్థితి వస్తుంది.

Cutover ప్రక్రియ, దశలవారీగా

  1. కొన్ని రోజుల ముందు: TTL విలువను తగ్గించండి, bulk rsync రన్ చేయండి, కొత్త సర్వర్‌ను సిద్ధం చేసి hosts override ద్వారా పరీక్షించండి.
  2. కటౌవర్ రోజున, సమయానికి ముందు: ప్రతి థర్డ్-పార్టీ allowlist లో కొత్త IPని చేర్చండి, కొత్త సర్వర్ బ్యాకప్ జాబ్ కాన్ఫిగర్ చేయబడి మీ రిపోజిటరీకి పాయింట్ అయిందో లేదో నిర్ధారించుకోండి.
  3. సమయం ప్రారంభం: పాత సర్వర్‌లో అప్లికేషన్‌ను maintenance mode లో ఉంచండి, తద్వారా అది కొత్త డేటాను స్వీకరించదు.
  4. చివరి డేటాబేస్ డంప్‌ను తీసుకోండి, ఆపై --delete తో చివరి rsync పాస్‌ను రన్ చేయండి.
  5. కొత్త సర్వర్‌లో డంప్‌ను రీస్టోర్ చేసి, సేవలను ప్రారంభించండి.
  6. --resolve మరియు hosts override ద్వారా మళ్ళీ పరీక్షించండి, ఒక నిజమైన రైట్ ఆపరేషన్‌ను కూడా పరీక్షించండి.
  7. A మరియు AAAA రికార్డులను కొత్త IPకి మార్చండి.
  8. రెండు సర్వర్లను గమనించండి. పాత సర్వర్ access log లో ఇంకా ఎవరెవరు వస్తున్నారో చూడవచ్చు, TTL ముగిసే సమయానికి ఈ సంఖ్య సున్నాకి చేరుకోవాలి.
  9. కొత్త సర్వర్‌లో maintenance పేజీని తొలగించండి; DNS క్యాష్ వల్ల పాత సర్వర్‌కు ట్రాఫిక్ వస్తున్నంత కాలం, అక్కడ రైట్ ఆపరేషన్లు జరగకుండా చూడండి.
  10. పాత సర్వర్‌ను కనీసం ఒక వారం పాటు అలాగే ఉంచండి, దేనినీ మార్చవద్దు.

Maintenance mode దశను చాలామంది విస్మరిస్తారు, కానీ ఇది మిమ్మల్ని రక్షించే ముఖ్యమైన దశ. కొత్త డేటాబేస్ ఒక రైట్ ఆపరేషన్‌ను స్వీకరించిన తర్వాత, వెనక్కి తగ్గడం (roll back) అంటే ఆ డేటాను కోల్పోవడం లేదా కొత్త డేటాబేస్‌ను డంప్ చేసి పాతదానిలోకి మళ్ళీ లోడ్ చేయడం వంటి కష్టమైన పనులు చేయాల్సి వస్తుంది. కొన్ని నిమిషాల పాటు రీడ్-ఓన్లీ మోడ్‌లో ఉంచడం చాలా సులభం. రెండు డేటాబేస్‌లలో రైట్ ఆపరేషన్లు జరిగితే, వాటిని సరిచేయడానికి రోజుల సమయం పడుతుంది.

రోల్‌బ్యాక్ ప్రణాళిక

కొత్త సర్వర్ ప్రొడక్షన్ రైట్స్ (writes) స్వీకరించడానికి ముందు, రోల్‌బ్యాక్ అంటే DNS రికార్డులను తిరిగి 198.51.100.10 కి మార్చడం మరియు పాత అప్లికేషన్‌లో రైట్స్‌ను తిరిగి ప్రారంభించడం. కొత్త సర్వర్ రైట్స్‌ను స్వీకరించిన తర్వాత, అక్కడ రైట్స్‌ను నిలిపివేసి, పాత సర్వర్‌ను తిరిగి ప్రారంభించే ముందు దాని డేటాబేస్ మరియు అప్‌లోడ్ చేసిన ఫైళ్లను పునరుద్ధరించాలి లేదా సరిపోల్చాలి. సరళమైన రోల్‌బ్యాక్ మీరు ముందుగా చేసిన నాలుగు అంశాలపై ఆధారపడి ఉంటుంది.

  • పాత సర్వర్ ఇంకా రన్ అవుతూ, దాని సేవలు అందుబాటులో ఉండి, డేటా చెక్కుచెదరకుండా ఉండాలి. మీరు అక్కడ రైట్స్‌ను మాత్రమే నిలిపివేశారు, దాన్ని డీకమిషన్ చేయలేదు.
  • TTL ఇంకా తక్కువగా ఉండాలి, తద్వారా వెనక్కి వెళ్లే ప్రక్రియ ముందుకు వెళ్లినంత వేగంగా జరుగుతుంది.
  • మీరు పాత IPని తొలగించకుండా, కొత్త IPని థర్డ్-పార్టీ allowlists కి జోడించారు. పాత అడ్రస్‌ను తొలగిస్తే, పేమెంట్ గేట్‌వే వద్ద మీ రోల్‌బ్యాక్ మార్గం విఫలమవుతుంది.
  • కొత్త సర్వర్‌లో మీరు గుర్తించలేని రైట్స్ ఏవీ జరగలేదు, ఎందుకంటే ఇప్పటివరకు జరిగిన రైట్స్ అన్నీ మీ స్వంత టెస్ట్ ట్రాన్సాక్షన్‌లు మాత్రమే.

విండో ప్రారంభం కావడానికి ముందే రోల్‌బ్యాక్‌ను ఏది ప్రేరేపిస్తుందో నిర్ణయించుకోండి. రెండు ట్రిగ్గర్లు సరిపోతాయి: నిర్ణీత నిమిషాల్లో మీరు నిర్ధారించలేని ఏదైనా ఎర్రర్, మరియు ఏవైనా డేటా నష్టం. వీటిని ముందుగానే రాసి పెట్టుకోవడం వల్ల, పది నిమిషాల అంతరాయాన్ని గంటల తరబడి సాగేలా చేసే ఊహాగానాలను నివారించవచ్చు.

మైగ్రేషన్ విజయవంతమైందని నిర్ధారించండి

సైట్ లోడ్ అయినప్పుడు మైగ్రేషన్ పూర్తయినట్లు కాదు. తర్వాత మాత్రమే విఫలమయ్యే అంశాలను పరిశీలించండి.

# new server
systemctl --failed
journalctl -p err -b --no-pager | tail -n 40
sudo certbot certificates
sudo systemctl list-timers --all --no-pager

systemctl --failed reporting 0 loaded units listed మీరు కోరుకునే ఫలితం. certbot certificates లో మీరు ఆశించే expiry dates కనిపించాలి. list-timers లో మీ inventoryలోని ప్రతి scheduled jobకు ఖాళీగా కాకుండా వాస్తవ next-run time కనిపించాలి.

తర్వాత కొత్త serverను ఉద్దేశపూర్వకంగా ఒకసారి reboot చేయండి. ఆ సమయంలో దాన్ని గమనిస్తూ ఉండండి. ఎవరైనా చేతితో start చేసి enable చేయని service, తెల్లవారుజామున మూడు గంటలకు జరిగే మొదటి అనుకోని reboot వరకు సరిగ్గా పనిచేస్తుంది.

# new server
sudo reboot

# your laptop, once it comes back
curl -sS -o /dev/null -w '%{http_code}\n' https://example.com/

అప్లికేషన్ containersలో నడుస్తుంటే ఇదే సమస్య వేరే రూపంలో కనిపిస్తుంది, ఎందుకంటే reboot తర్వాత తిరిగి ప్రారంభించడానికి compose stackకు స్పష్టమైన restart policy అవసరం.

వాయిదా వేయడం సులభమైనదైనా, అత్యంత ముఖ్యమైన చివరి తనిఖీ backup job. backup లేని serverతో ముగిసే migration ఒక ప్రమాదాన్ని మరొక ప్రమాదంతో మార్చినట్లే. కొత్త boxలో backupను చేతితో run చేసి, దానిలోని ఒక fileను temporary directoryకి restore చేయండి. మీరు వాస్తవంగా పరీక్షించిన restoreతో కూడిన restic repository ఈ అవసరానికి ఉపయోగపడే రూపం. పాత మరియు కొత్త serverలను ఒక వారం పాటు పక్కపక్కనే నడుపుతున్నట్లయితే, ప్రతి hostను చేరుకోవడానికి మరియు configure చేయడానికి ఒక స్థిరమైన విధానం రెండూ liveగా ఉన్నప్పుడు వాటి configurationలు వేరుపడకుండా నిరోధిస్తుంది.

Cutover తర్వాత: పాత సర్వర్ మరియు చివరి అంశాలు

పాత సర్వర్‌ను ఒకటి నుండి రెండు వారాల పాటు ఉంచండి. దానిని ఎంతకాలం ఉంచాలో నిర్ణయించుకునే ముందు పాత ప్లాన్ యొక్క బిల్లింగ్ మరియు రద్దు నిబంధనలను తనిఖీ చేయండి. ఆ తర్వాత మిగిలిన వాటిని ముగించండి.

  • కొత్త సర్వర్ కోసం మీ ~/.ssh/config లో అదే hostname ను మళ్లీ ఉపయోగించినప్పుడు, మొదటి కనెక్షన్‌లోనే మీకు WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! వస్తుంది, ఎందుకంటే ఆ పేరు ఇప్పుడు వేరే host key తో స్పందిస్తుంది. అది ఎందుకు మారిందో మీకు ఖచ్చితంగా తెలిసిన తర్వాత మాత్రమే ssh-keygen -R example.com తో పాత ఎంట్రీని తొలగించండి. కేవలం అలవాటుగా చేయకండి, ఎందుకంటే ఇదే హెచ్చరిక ఒక interception attack జరిగినప్పుడు కూడా కనిపిస్తుంది. మైగ్రేషన్ అనేది ఏ కీలు దేనిని యాక్సెస్ చేయగలవో సమీక్షించుకోవడానికి కూడా మంచి సమయం, దీని కోసమే SSH key management on a small fleet ఉంది.
  • పాత సర్వర్ యొక్క ఒక చివరి snapshot లేదా backup తీసుకోండి మరియు దానిని పాత ప్రొవైడర్ సర్వర్లు కాని చోట భద్రపరచండి.
  • పాత IP ని monitoring checks, SPF records, మరియు third-party allowlists నుండి తొలగించండి; ఈ క్రమంలోనే చేయండి మరియు చివరగా వీటిని చేయండి.
  • ఆ చివరి కాపీ మరొక చోట చదవడానికి వీలుగా ఉందని నిర్ధారించుకున్న తర్వాతే పాత ప్లాన్‌ను రద్దు చేయండి.

FAQ

ఒక సర్వర్‌ను కొత్త VPSకి మార్చడానికి ఎంత సమయం పడుతుంది?

వినియోగదారులకు కనిపించే అంతరాయం సాధారణంగా చివరి డేటాబేస్ డంప్, చివరి rsync పాస్ మరియు సర్వీస్ ప్రారంభమయ్యే సమయానికి మాత్రమే పరిమితం అవుతుంది; మీ విండోను అంచనా వేయడానికి ఈ దశలను ఒకసారి రిహార్సల్ చేసి సమయాన్ని లెక్కించండి. క్యాలెండర్ సమయం ఎక్కువగా ఉంటుంది, ఎందుకంటే DNS TTLని మార్పుకు కనీసం పాత-TTL కాలానికి ముందే తగ్గించాలి, ఒక రోజు ముందుగా చేయడం మరింత సురక్షితం. భారీ డేటా కాపీని కూడా రోజుల ముందే ప్లాన్ చేయండి. ఇది లైవ్ సర్వర్‌పై నడుస్తుంది, మరియు తర్వాత మళ్ళీ రన్ చేసినప్పుడు చివరి పాస్ నుండి మారిన డేటాను మాత్రమే బదిలీ చేస్తుంది.

నేను రన్ అవుతున్న MySQL లేదా PostgreSQL డేటాబేస్‌ను డంప్ చేయడానికి బదులుగా నేరుగా rsync చేయవచ్చా?

లేదు. డేటాబేస్ ఒకేసారి అనేక ఫైళ్లకు రాస్తున్నప్పుడు rsync ఫైల్ వారీగా కాపీ చేస్తుంది, కాబట్టి ఆ కాపీలో వివిధ సమయాల్లోని పేజీలు ఉంటాయి మరియు డేటాబేస్ ఎప్పుడూ లేని స్థితిని అది సూచిస్తుంది. అది ప్రారంభం కాకపోవచ్చు, లేదా ప్రారంభమైనా ఏదైనా క్వెరీ దెబ్బతిన్న పేజీని చేరుకున్నప్పుడు విఫలం కావచ్చు. pg_dump తో pg_dumpall --globals-only ని ఉపయోగించండి, లేదా mysqldump --single-transaction (MariaDB 11 మరియు ఆ తర్వాత వెర్షన్లలో mariadb-dump) వాడండి, లేదా ముందుగా డేటాబేస్‌ను ఆపివేసి ఆపై ఫైళ్లను కాపీ చేయండి. పెద్ద PostgreSQL క్లస్టర్ కోసం, pg_basebackup రన్ అవుతున్న సర్వర్ యొక్క స్థిరమైన ఫిజికల్ కాపీని తయారు చేస్తుంది.

DNS మార్చడానికి ముందు కొత్త VPSని నేను ఎలా పరీక్షించాలి?

మీ స్వంత మెషీన్‌లో నేమ్ లుకప్‌ను ఓవర్‌రైడ్ చేయండి. ఒకే అభ్యర్థన కోసం, curl --resolve example.com:443:203.0.113.20 https://example.com/ కనెక్షన్‌ను కొత్త IPకి పంపుతుంది, అదే సమయంలో సర్టిఫికేట్‌ను అసలు పేరుతో సరిచూస్తుంది. బ్రౌజర్ టెస్టింగ్ కోసం, మీ ల్యాప్‌టాప్‌లోని /etc/hosts ఫైల్‌కు 203.0.113.20 example.com ని జోడించండి, లాగిన్, డేటాబేస్ రీడ్, ఫారమ్ రైట్ మరియు ఫైల్ అప్‌లోడ్‌లను పరీక్షించి, ఆపై ఆ లైన్‌ను తొలగించండి. కేవలం సర్టిఫికేట్‌ను మాత్రమే తనిఖీ చేయడానికి, openssl s_client -connect 203.0.113.20:443 -servername example.com రన్ చేయండి.

నేను ఎంత TTL సెట్ చేయాలి, మరియు దానిని ఎప్పుడు తగ్గించాలి?

A మరియు AAAA రికార్డులను 300 సెకన్లకు తగ్గించండి, మరియు దీనిని కటౌవర్‌కు కనీసం ఒక పూర్తి పాత-TTL కాలానికి ముందే చేయండి. మీ మార్పుకు ముందు రికార్డును కాష్ చేసిన రిజాల్వర్ పాత TTL ముగిసే వరకు పాత విలువనే ఉంచుకుంటుంది, కాబట్టి పాత TTL 86400 ఉన్నప్పుడు ఒక గంట ముందుగా తగ్గించడం వల్ల ఆ గంటలో ఎక్స్‌పైర్ అయ్యి తక్కువ TTLని పొందే కాష్‌లకు మాత్రమే ప్రయోజనం ఉంటుంది; మిగిలినవి పాత సమాచారాన్నే కలిగి ఉంటాయి. మైగ్రేషన్ తర్వాత కొన్ని రోజులకు, పాత సర్వర్ యాక్సెస్ లాగ్ నిశ్శబ్దంగా మారిన తర్వాత, దానిని తిరిగి సాధారణ విలువకు పెంచండి.

నేను TLS సర్టిఫికేట్‌ను కాపీ చేయాలా లేదా కొత్త సర్వర్‌పై కొత్తది జారీ చేయాలా?

ఏదైనా చేయవచ్చు. /etc/letsencrypt/ ని కాపీ చేయడం వల్ల సర్టిఫికేట్ దాని ప్రస్తుత గడువు తేదీ వరకు చెల్లుబాటు అవుతుంది, కానీ మీరు కొత్త సర్వర్‌పై అదే certbot అథెంటికేటర్ ప్లగిన్‌ను ఇన్‌స్టాల్ చేయాలి, లేకపోతే మొదటి రెన్యూవల్ విఫలమవుతుంది. కాబట్టి DNS స్విచ్ తర్వాత లేదా వాలిడేషన్ ఫార్వార్డింగ్‌ను కాన్ఫిగర్ చేసిన తర్వాత నిర్ధారించుకోవడానికి certbot renew --dry-run రన్ చేయండి. మీరు DNS-01 ఛాలెంజ్‌ను ఉపయోగించగలిగినప్పుడు కొత్త సర్టిఫికేట్‌ను జారీ చేయడం సులభం, ఎందుకంటే ఇది TXT రికార్డ్ ద్వారా నియంత్రణను నిరూపిస్తుంది మరియు DNS కొత్త సర్వర్‌కు పాయింట్ చేయకముందే పనిచేస్తుంది. పాత సర్వర్ మ్యాచింగ్ ఛాలెంజ్ రెస్పాన్స్‌ను అందిస్తే లేదా వాలిడేషన్ అభ్యర్థనలను కొత్త సర్వర్‌కు పాయింట్ చేసే వేరే పబ్లిక్ హోస్ట్‌నేమ్‌కు రీడైరెక్ట్ చేస్తే, సైట్ DNS మారకముందే HTTP-01 కూడా పనిచేస్తుంది.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?