ఎవరినీ వేచి ఉంచకుండా పెద్ద వర్క్‌స్పేస్‌లకు మారడం

Mythex లోని ప్రతి ప్రాజెక్ట్‌కు దాని స్వంత వర్క్‌స్పేస్ లభిస్తుంది: ఏజెంట్ కోడ్ రాసే, మరియు మీ యాప్ ప్రివ్యూ నడిచే ఒక చిన్న క్లౌడ్ కంప్యూటర్. కొత్త వర్క్‌స్పేస్‌లను 1 GB మెమరీ నుండి 2 GB కు పెంచాము, కానీ పాత వాటు 1 GB వద్దనే ఉన్నాయి — మేము తనిఖీ చేసిన రోజున, వాటిలో దాదాపు నాలుగో వంతు. మా మొదటి పరిష్కారం ఒక ప్రాజెక్ట్‌ను దాని తదుపరి తెరవడంలో పెద్ద వర్క్‌స్పేస్‌కు తరలించింది. ప్రొడక్షన్‌లో మొదటి రోజున, అది ఒకరిని ఏడు నిమిషాలు వేచి ఉంచింది. మేము దానికి కఠినమైన సమయ పరిమితి పెట్టాము, ఆ తర్వాత ప్రాజెక్ట్ తెరవడం నుండి తరలింపునే పూర్తిగా తీసేశాము.

పాత వర్క్‌స్పేస్‌లు ఎందుకు చిన్నవిగా ఉండిపోయాయి

మా శాండ్‌బాక్స్ ప్రొవైడర్ ఒక వర్క్‌స్పేస్ పరిమాణాన్ని అది సృష్టించబడినప్పుడు నిర్ణయిస్తుంది, మరియు ప్రతి పాజ్ మరియు రీస్టార్ట్ ద్వారా దాన్ని నిలుపుకుంటుంది. టెంప్లేట్ మార్చడం — కొత్త వర్క్‌స్పేస్‌లు నిర్మించబడే వంటకం — మార్పు తర్వాత సృష్టించబడిన వర్క్‌స్పేస్‌లపై మాత్రమే ప్రభావం చూపుతుంది. ఇప్పటికే ఉన్నవాటిని ఏదీ పరిమాణం మార్చదు.

అది ముఖ్యమైనది. చిన్న వర్క్‌స్పేస్‌లలో ఒకటి దాని ప్రివ్యూ ప్రారంభమవుతున్నప్పుడు git push సమయంలో మెమరీ అయిపోయింది, మరియు 11 నిమిషాల పాటు స్పందించలేదు. దాని వల్ల ఒక పబ్లిష్ విఫలమైంది.

మొదటి ప్రయత్నం: మేల్కొన్నప్పుడు ప్రాజెక్ట్‌ను తరలించడం

ఎవరూ ఉపయోగించనప్పుడు వర్క్‌స్పేస్‌లు పాజ్ అవుతాయి, మరియు ప్రాజెక్ట్ తెరిచినప్పుడు మేల్కొంటాయి. మేల్కొనడం ప్రాజెక్ట్‌ను తరలించడానికి సరైన క్షణంగా అనిపించింది, ఎందుకంటే అప్పటికి ఎవరూ దానిపై పనిచేయడం మొదలుపెట్టలేదు.

తరలింపు ఇలా పనిచేసింది:

1. పరిమాణం తనిఖీ చేయండి. వర్క్‌స్పేస్ 2 GB కంటే చిన్నగా ఉంటే, తరలించండి. దాని పరిమాణం తెలియకపోతే, ఏమీ చేయకండి.
2. పబ్లిష్‌కు భంగం కలిగించకండి. పబ్లిష్ వర్క్‌స్పేస్ ఫైళ్లను చదువుతుంది, కాబట్టి అది నడుస్తుంటే, తరలింపును దాటవేయండి.
3. ప్రాజెక్ట్‌ను ప్యాక్ చేయండి. ప్రాజెక్ట్‌లోని ప్రతిదాన్ని ఆర్కైవ్ చేయండి — దాని git హిస్టరీతో సహా, అంటే ప్రాజెక్ట్‌కు ఉన్న ప్రతి చెక్‌పాయింట్, మరియు యాప్ యొక్క స్వంత .env ఫైల్, అది యజమానికి చెందినది — కానీ ఇన్‌స్టాల్ చేసిన డిపెండెన్సీలను (node_modules) వదిలేయండి, అవి మళ్లీ ఇన్‌స్టాల్ చేయవచ్చు.
4. నేరుగా అవతలికి కాపీ చేయండి. పాత వర్క్‌స్పేస్ నుండి ఆర్కైవ్‌ను కొత్త 2 GB వర్క్‌స్పేస్‌లోకి స్ట్రీమ్ చేయండి, తద్వారా అది మా స్వంత సర్వర్ మెమరీలో ఎప్పుడూ సరిపోవాల్సిన అవసరం ఉండదు.
5. మారే ముందు పోల్చండి. రెండు వర్క్‌స్పేస్‌లలో ఫైళ్ల సంఖ్యను, తాజా చెక్‌పాయింట్‌ను, మరియు చెక్‌పాయింట్ల సంఖ్యను లెక్కించండి. మూడూ సరిపోతేనే మారండి.
6. ఏ విఫలత అయినా పాతదాన్ని ఉంచండి. ఏ ఎర్రర్ లేదా అసమతుల్యత అయినా కొత్త వర్క్‌స్పేస్‌ను తీసేస్తుంది, మరియు ప్రాజెక్ట్‌ను ముందులాగే పాత దానిలో తెరుస్తుంది.

పోలికలోని ఒక వివరం అది కనిపించేదానికంటే ఎక్కువ ముఖ్యమైంది. తనిఖీ అడ్మినిస్ట్రేటర్ ఖాతాగా నడుస్తుంది, మరియు వేరే యూజర్ యాజమాన్యంలోని రిపోజిటరీని git చదవడానికి నిరాకరిస్తుంది. రెండు వైపులా అది ఏమీ ప్రింట్ చేయలేదు — మరియు “ఏమీ లేదు” అనేది “ఏమీ లేదు”తో సరిపోయింది, కాబట్టి తనిఖీ ఏ హిస్టరీని పోల్చకుండానే పాసైంది. మేము git కు ఆ డైరెక్టరీని నమ్మమని చెప్పాము, మరియు అది మళ్లీ జారిపోకుండా ఒక టెస్ట్ జోడించాము.

ప్రొడక్షన్‌లో మొదటి రోజున ఏమి తప్పు జరిగింది

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

తమ స్వంత ప్రాజెక్ట్ తెరిచేటప్పుడు ఒకరిని వేచి ఉంచే మైగ్రేషన్ చెడ్డ వ్యాపారం. దాన్ని మేల్కొనే సమయంలో చేయడంలోని మొత్తం ఉద్దేశం ఎవరూ గమనించకూడదని.

రెండవ ప్రయత్నం: కఠినమైన బడ్జెట్

అదే రోజు మేము నాలుగు విషయాలు మార్చాము:

• మొత్తం తరలింపుకు ఒక నిమిషం. ప్రతి అడుగు — పరిమాణం తనిఖీ, ప్యాకింగ్, కొత్త వర్క్‌స్పేస్ సృష్టి, కాపీ, అన్‌ప్యాకింగ్, పోలిక — ఒకే 60-సెకన్ల బడ్జెట్‌ను పంచుకుంటుంది. అది అయిపోయినప్పుడు, ప్రాజెక్ట్ పాత వర్క్‌స్పేస్‌లో తెరుచుకుంటుంది.
• పని ఆపండి, కేవలం వేచి ఉండటం కాదు. మా వైపు వదిలేయడం సరిపోదు, యజమాని ఉపయోగించబోయే వర్క్‌స్పేస్ లోపల ఆర్కైవింగ్ ఇంకా నడుస్తుంటే. ప్రతి ఆర్కైవ్ కమాండ్ ఇప్పుడు బడ్జెట్ ముగియడానికి కొద్ది ముందే వర్క్‌స్పేస్ లోపలే చంపబడుతుంది. మేము వదిలేసిన తర్వాత కొత్త వర్క్‌స్పేస్ వస్తే, అది పారేయబడుతుంది.
• యజమానిని క్లీనప్ కోసం వేచి ఉంచవద్దు. తాత్కాలిక ఆర్కైవ్‌ను తొలగించడం ఇప్పుడు బ్యాక్‌గ్రౌండ్‌లో జరుగుతుంది.
• ప్రతి తెరవడంలో మళ్లీ ప్రయత్నించవద్దు. తరలించలేని ప్రాజెక్ట్ 24 గంటల పాటు వదిలేయబడుతుంది, కాబట్టి ఒక విఫలత రోజుకు ఒక్క ఆలస్యం మాత్రమే ఖర్చవుతుంది, ప్రతి తెరవడానికి ఒకటి కాదు.

మూడవ ప్రయత్నం: దాన్ని మేల్కొనడం నుండి తీసేయండి

అది చెత్త సందర్భాన్ని ఒక నిమిషానికి తగ్గించింది. కానీ ఒక నిమిషం ఇంకా ఒక నిమిషమే, మరియు తరలింపు ఎవరి మార్గంలోనూ ఉండాల్సిన అవసరం లేదని మేము గ్రహించాము.

ఇప్పుడు 1 GB వద్ద ఏ వర్క్‌స్పేస్ సృష్టించబడటం లేదు. కాబట్టి ఇది కొనసాగే ప్రక్రియ కాదు; ఇది స్థిరమైన వర్క్‌స్పేస్ జాబితాతో ఒక్కసారి చేసే ఉద్యోగం. దాన్ని మేల్కొనే సమయంలో ఉంచడం అంటే ప్రతి నెమ్మది తరలింపుకు ఒక నిజమైన వ్యక్తి చెల్లించాడు, మరియు వర్క్‌స్పేస్ తరలించబడదని తెలుసుకోవడానికి ఏకైక మార్గం ఎవరో దాని కోసం ఇప్పుడే వేచి ఉండటమే.

కాబట్టి మేము తరలింపును మేల్కొనడం నుండి పూర్తిగా తీసేశాము. ప్రాజెక్ట్ తెరవడం ముందులాగే చేస్తుంది. మిగిలిన చిన్న వర్క్‌స్పేస్‌లను బదులుగా ఒక పర్యవేక్షించబడిన బ్యాచ్‌గా నిర్వహిస్తాము: ఎవరూ దానికోసం వేచి ఉండరు, మరియు తరలించలేని వర్క్‌స్పేస్ బ్యాచ్ నివేదికలో కనిపిస్తుంది, అక్కడ మేము దాన్ని పరిశీలించగలము — దాని యజమాని ముందు కాకుండా.

మేము దీనినుండి నేర్చుకున్నది

• పరిమాణం మార్చడం ఎల్లప్పుడూ సాధ్యం కాదు. ఒక ప్లాట్‌ఫామ్ సృష్టి సమయంలో పరిమాణాన్ని స్థిరం చేస్తే, డిఫాల్ట్‌ను పెంచడం కొత్త వాటికే సహాయపడుతుంది. పాత వాటి కోసం ప్లాన్ చేయండి.
• “ఇంకా ఎవరూ ఉపయోగించడం లేదు” అంటే ఇంకా ఒకరు వేచి ఉన్నారని అర్థం. ఉత్పత్తిలోకి వెళ్లే దారిలో చేసే పని ఒక వ్యక్తి చూసే పని.
• వినియోగదారు మార్గంలో ఉన్న ఏదైనా పనికి బడ్జెట్ పెట్టండి, మరియు అది అయిపోయినప్పుడు పనిని ఆపండి. మన వైపు టైమ్‌అవుట్ అవుతూ, కమాండ్ మరెక్కడో నడుస్తూ ఉంటే సమస్యను మాత్రమే కదిలిస్తుంది.
• ఒక్కసారి చేసే మైగ్రేషన్ ఒక్కసారి చేసే ఉద్యోగంలోనే ఉండాలి. దాన్ని రోజువారీ చర్యల్లో దాచడం రాయడానికి చౌకగా, నడపడానికి ఖరీదుగా చేస్తుంది.
• మీ భద్రతా తనిఖీలను పరీక్షించండి. ఏమీ పోల్చని పోలిక, ఉత్తీర్ణత సాధించిన పోలికలాగే కనిపిస్తుంది.

మీరు Mythex పై నిర్మిస్తుంటే, చేయాల్సింది ఏమీ లేదు: లక్ష్యం కేవలం తక్కువ వర్క్‌స్పేస్‌లు మెమరీ అయిపోవడం, ప్రాజెక్ట్ తెరవడం ముందులాగే వేగంగా ఉండటం. వర్క్‌స్పేస్‌లు ఎలా పాజ్ మరియు మేల్కొంటాయో ప్రైవేట్ వర్క్‌స్పేస్ కింద డాక్స్‌లో ఉంది. మరో మెమరీ-అయిపోయిన కథ కోసం, ప్రోగ్రెస్ లేబుల్‌లో దాగి ఉన్న out-of-memory క్రాష్ చూడండి.