డాకర్ మరియు గిట్లాబ్ CIతో అభివృద్ధి మరియు పరీక్ష ప్రక్రియ

ఇన్వెంటోస్ “డాకర్ + గిట్‌లాబ్ CIతో డెవలప్‌మెంట్ అండ్ టెస్టింగ్ ప్రాసెస్” నుండి అలెగ్జాండర్ సిగాచెవ్ రిపోర్టు యొక్క ట్రాన్స్క్రిప్ట్ చదవమని నేను మీకు సూచిస్తున్నాను.

డాకర్ + గిట్‌లాబ్ CI ఆధారంగా అభివృద్ధి మరియు పరీక్ష ప్రక్రియను అమలు చేయడం ప్రారంభించిన వారు తరచుగా ప్రాథమిక ప్రశ్నలు అడుగుతారు. ఎక్కడ ప్రారంభించాలి? ఎలా నిర్వహించాలి? ఎలా పరీక్షించాలి?

ఈ నివేదిక మంచిది ఎందుకంటే ఇది డాకర్ మరియు గిట్‌లాబ్ CIని ఉపయోగించి అభివృద్ధి మరియు పరీక్ష ప్రక్రియ గురించి నిర్మాణాత్మక పద్ధతిలో మాట్లాడుతుంది. నివేదిక 2017 నాటిది. ఈ నివేదిక నుండి మీరు బేసిక్స్, మెథడాలజీ, ఆలోచన మరియు ఉపయోగం యొక్క అనుభవాన్ని సేకరించవచ్చని నేను భావిస్తున్నాను.

ఆసక్తి ఉన్న ఎవరైనా, దయచేసి పిల్లిని చూడండి.

నా పేరు అలెగ్జాండర్ సిగాచెవ్. నేను ఇన్వెంటోస్ కోసం పని చేస్తున్నాను. డాకర్‌ని ఉపయోగించి నా అనుభవం గురించి మరియు కంపెనీలోని ప్రాజెక్ట్‌లలో మేము దానిని క్రమంగా ఎలా అమలు చేస్తున్నామో నేను మీకు చెప్తాను.

నివేదిక యొక్క అంశం: డాకర్ మరియు గిట్లాబ్ CI ఉపయోగించి అభివృద్ధి ప్రక్రియ.

డాకర్ గురించి ఇది నా రెండవ చర్చ. మొదటి నివేదిక సమయంలో, మేము డెవలపర్ మెషీన్‌లలో డెవలప్‌మెంట్‌లో మాత్రమే డాకర్‌ని ఉపయోగించాము. డాకర్‌ని ఉపయోగించిన ఉద్యోగుల సంఖ్య దాదాపు 2-3 మంది. క్రమంగా, అనుభవం సంపాదించబడింది మరియు మేము కొంచెం ముందుకు వెళ్ళాము. మా లింక్ మొదటి నివేదిక.

ఈ నివేదికలో ఏమి ఉంటుంది? మేము ఏ రేక్‌లను సేకరించాము, ఏ సమస్యలను పరిష్కరించాము అనే దాని గురించి మేము మా అనుభవాన్ని పంచుకుంటాము. ఇది ప్రతిచోటా అందంగా లేదు, కానీ అది మాకు కొనసాగడానికి అనుమతించింది.

మా నినాదం: మన చేతికి దొరికిన ప్రతిదాన్ని డాకరైజ్ చేయండి.

మేము ఏ సమస్యలను పరిష్కరిస్తున్నాము?

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

ప్రోగ్రామర్ త్వరగా అర్థం చేసుకోవడానికి, అతను ప్రాజెక్ట్ యొక్క సోర్స్ కోడ్‌ను డౌన్‌లోడ్ చేసుకోవాలి మరియు వీలైనంత త్వరగా వాతావరణాన్ని ప్రారంభించాలి, ఇది ఈ ప్రాజెక్ట్ యొక్క సమస్యలను పరిష్కరించడంలో మరింత ముందుకు సాగడానికి అతన్ని అనుమతిస్తుంది.

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

డెవలప్‌మెంట్‌లో సెట్టింగ్‌ల ప్రామాణీకరణ తదుపరి కారణం. నా అనుభవంలో, డెవలపర్లు ఎల్లప్పుడూ చొరవ తీసుకుంటారు. ప్రతి ఐదవ సందర్భంలో, అనుకూల డొమైన్ నమోదు చేయబడుతుంది, ఉదాహరణకు vasya.dev. నా పక్కన కూర్చున్న నా పొరుగు పెట్యా, అతని డొమైన్ petya.dev. వారు ఈ డొమైన్ పేరును ఉపయోగించి వెబ్‌సైట్ లేదా కొంత సిస్టమ్ కాంపోనెంట్‌ను అభివృద్ధి చేస్తారు.

సిస్టమ్ పెరిగినప్పుడు మరియు ఈ డొమైన్ పేర్లను కాన్ఫిగరేషన్‌లో చేర్చడం ప్రారంభించినప్పుడు, డెవలప్‌మెంట్ ఎన్విరాన్‌మెంట్‌లలో వివాదం తలెత్తుతుంది మరియు సైట్ మార్గం తిరిగి వ్రాయబడుతుంది.

డేటాబేస్ సెట్టింగ్‌లతో కూడా అదే జరుగుతుంది. కొందరు వ్యక్తులు భద్రతతో బాధపడరు మరియు ఖాళీ రూట్ పాస్‌వర్డ్‌తో పని చేస్తారు. ఇన్‌స్టాలేషన్ దశలో, MySQL ఎవరినైనా పాస్‌వర్డ్ కోసం అడిగారు మరియు పాస్‌వర్డ్ 123గా మారింది. డెవలపర్ యొక్క నిబద్ధతపై ఆధారపడి డేటాబేస్ కాన్ఫిగర్ నిరంతరం మారుతూ ఉంటుంది. ఎవరో సరిదిద్దారు, ఎవరో కాన్ఫిగర్‌ని సరిచేయలేదు. మేము కొన్ని పరీక్ష కాన్ఫిగరేషన్‌ను ఉంచినప్పుడు ఉపాయాలు ఉన్నాయి .gitignore మరియు ప్రతి డెవలపర్ డేటాబేస్ను ఇన్‌స్టాల్ చేయాలి. ఇది ప్రారంభ ప్రక్రియను మరింత కష్టతరం చేసింది. ఇతర విషయాలతోపాటు, మీరు డేటాబేస్ గురించి గుర్తుంచుకోవాలి. డేటాబేస్ తప్పనిసరిగా ప్రారంభించబడాలి, పాస్‌వర్డ్ నమోదు చేయబడాలి, వినియోగదారుని నమోదు చేయాలి, ఒక సంకేతం సృష్టించబడాలి మరియు మొదలైనవి.

మరొక సమస్య లైబ్రరీల యొక్క విభిన్న సంస్కరణలు. డెవలపర్ వేర్వేరు ప్రాజెక్ట్‌లలో పని చేయడం తరచుగా జరుగుతుంది. ఐదు సంవత్సరాల క్రితం (2017 నుండి - ఎడిటర్స్ నోట్) ప్రారంభమైన లెగసీ ప్రాజెక్ట్ ఉంది. ప్రారంభంలో మేము MySQL 5.5తో ప్రారంభించాము. మేము MySQL యొక్క మరింత ఆధునిక సంస్కరణలను అమలు చేయడానికి ప్రయత్నిస్తున్న ఆధునిక ప్రాజెక్ట్‌లు కూడా ఉన్నాయి, ఉదాహరణకు 5.7 లేదా అంతకంటే పాతవి (2017లో - ఎడిటర్స్ నోట్)

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

డెవలపర్ స్థానిక మెషీన్‌లో పనిచేసినప్పుడు తదుపరి సమస్య, అతను స్థానిక వనరులు, స్థానిక ఫైల్‌లు, స్థానిక RAMని ఉపయోగిస్తాడు. సమస్యలకు పరిష్కారాన్ని అభివృద్ధి చేసే సమయంలో అన్ని పరస్పర చర్య అది ఒక యంత్రంపై పనిచేసే వాస్తవం యొక్క చట్రంలో నిర్వహించబడుతుంది. మేము ఉత్పత్తి 3లో బ్యాకెండ్ సర్వర్‌లను కలిగి ఉన్నప్పుడు మరియు డెవలపర్ ఫైల్‌లను రూట్ డైరెక్టరీకి సేవ్ చేసినప్పుడు మరియు అక్కడ నుండి nginx అభ్యర్థనకు ప్రతిస్పందించడానికి ఫైల్‌లను తీసుకుంటే ఒక ఉదాహరణ. అటువంటి కోడ్ ఉత్పత్తిలోకి వచ్చినప్పుడు, ఫైల్ 3 సర్వర్‌లలో ఒకదానిలో ఉన్నట్లు తేలింది.

మైక్రోసర్వీస్‌ల దిశ ప్రస్తుతం అభివృద్ధి చెందుతోంది. మేము మా పెద్ద అప్లికేషన్‌లను ఒకదానితో ఒకటి పరస్పర చర్య చేసే కొన్ని చిన్న భాగాలుగా విభజించినప్పుడు. నిర్దిష్ట టాస్క్ స్టాక్ కోసం సాంకేతికతలను ఎంచుకోవడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది. డెవలపర్‌ల మధ్య పని మరియు బాధ్యత యొక్క ప్రాంతాన్ని విభజించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది.

JSలో అభివృద్ధి చెందుతున్న ఫ్రంటెండ్ డెవలపర్ వాస్తవంగా బ్యాకెండ్‌పై ప్రభావం చూపదు. బ్యాకెండ్ డెవలపర్, మా విషయంలో, రూబీ ఆన్ రైల్స్‌ను అభివృద్ధి చేస్తుంది మరియు ఫ్రెండెండ్‌తో జోక్యం చేసుకోదు. APIని ఉపయోగించి పరస్పర చర్య జరుగుతుంది.

బోనస్‌గా, డాకర్‌ని ఉపయోగించి మేము స్టేజింగ్‌లో వనరులను రీసైకిల్ చేయగలిగాము. ప్రతి ప్రాజెక్ట్, దాని ప్రత్యేకతల కారణంగా, నిర్దిష్ట సెట్టింగ్‌లు అవసరం. భౌతికంగా, వర్చువల్ సర్వర్‌ను కేటాయించడం మరియు వాటిని విడిగా కాన్ఫిగర్ చేయడం లేదా ఒక రకమైన వేరియబుల్ ఎన్విరాన్‌మెంట్‌ను విభజించడం అవసరం మరియు లైబ్రరీల సంస్కరణపై ఆధారపడి ప్రాజెక్ట్‌లు ఒకదానికొకటి ప్రభావితం చేయగలవు.

ఉపకరణాలు. మనం ఏమి ఉపయోగిస్తాము?

• డాకర్ స్వయంగా. Dockerfile ఒకే అప్లికేషన్ యొక్క డిపెండెన్సీలను వివరిస్తుంది.
• డాకర్-కంపోజ్ అనేది మా అనేక డాకర్ అప్లికేషన్‌లను ఒకచోట చేర్చే బండిల్.
• మేము సోర్స్ కోడ్‌ని నిల్వ చేయడానికి GitLabని ఉపయోగిస్తాము.
• సిస్టమ్ ఇంటిగ్రేషన్ కోసం మేము GitLab-CIని ఉపయోగిస్తాము.

నివేదిక రెండు భాగాలను కలిగి ఉంటుంది.

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

రెండవ భాగం GitLabతో ఎలా ఇంటరాక్ట్ అవ్వాలి, మేము పరీక్షలను ఎలా అమలు చేస్తాము మరియు స్టేజింగ్‌కి ఎలా వెళ్లాలి అనే దాని గురించి మాట్లాడుతుంది.

డాకర్ అనేది అవసరమైన భాగాలను వివరించడానికి (డిక్లరేటివ్ విధానాన్ని ఉపయోగించి) అనుమతించే సాంకేతికత. ఇది ఒక ఉదాహరణ డాకర్‌ఫైల్. రూబీ:2.3.0 యొక్క అధికారిక డాకర్ చిత్రం నుండి మేము వారసత్వంగా పొందుతున్నామని ఇక్కడ మేము ప్రకటిస్తాము. ఇది రూబీ వెర్షన్ 2.3 ఇన్‌స్టాల్ చేయబడింది. మేము అవసరమైన అసెంబ్లీ లైబ్రరీలను మరియు NodeJSని ఇన్‌స్టాల్ చేస్తాము. మేము డైరెక్టరీని సృష్టిస్తున్నామని వివరిస్తాము /app. మేము యాప్ డైరెక్టరీని వర్కింగ్ డైరెక్టరీగా కేటాయిస్తాము. ఈ డైరెక్టరీలో మేము అవసరమైన కనీస Gemfile మరియు Gemfile.lockని ఉంచుతాము. అప్పుడు మేము ఈ డిపెండెన్సీ ఇమేజ్‌ని ఇన్‌స్టాల్ చేసే ప్రాజెక్ట్‌లను నిర్మిస్తాము. బాహ్య పోర్ట్ 3000లో వినడానికి కంటైనర్ సిద్ధంగా ఉంటుందని మేము సూచిస్తున్నాము. చివరి ఆదేశం మా అప్లికేషన్‌ను నేరుగా ప్రారంభించే ఆదేశం. మేము ప్రాజెక్ట్ రన్ ఆదేశాన్ని అమలు చేస్తే, అప్లికేషన్ పేర్కొన్న ఆదేశాన్ని అమలు చేయడానికి మరియు అమలు చేయడానికి ప్రయత్నిస్తుంది.

ఇది డాకర్-కంపోజ్ ఫైల్‌కి కనిష్ట ఉదాహరణ. ఈ సందర్భంలో, రెండు కంటైనర్ల మధ్య కనెక్షన్ ఉందని మేము చూపిస్తాము. ఇది నేరుగా డేటాబేస్ సేవ మరియు వెబ్ సేవలో ఉంటుంది. మా వెబ్ అప్లికేషన్‌లకు చాలా సందర్భాలలో డేటాను నిల్వ చేయడానికి బ్యాకెండ్‌గా ఒక రకమైన డేటాబేస్ అవసరం. మేము MySQLని ఉపయోగిస్తాము కాబట్టి, ఉదాహరణ MySQLతో ఉంటుంది - కానీ కొన్ని ఇతర డేటాబేస్ (PostgreSQL, Redis)ని ఉపయోగించకుండా మనల్ని ఏదీ నిరోధించదు.

మేము డాకర్ హబ్ నుండి అధికారిక మూలం నుండి మార్పులు లేకుండా MySQL 5.7.14 చిత్రాన్ని తీసుకుంటాము. మేము ప్రస్తుత డైరెక్టరీ నుండి మా వెబ్ అప్లికేషన్‌కు బాధ్యత వహించే చిత్రాన్ని సేకరిస్తాము. మొదటి లాంచ్ సమయంలో, అతను మన కోసం ఒక చిత్రాన్ని సేకరిస్తాడు. అప్పుడు మనం ఇక్కడ అమలు చేస్తున్న కమాండ్‌ను ఇది అమలు చేస్తుంది. మనం వెనక్కి వెళితే, లాంచ్ కమాండ్ ప్యూమా ద్వారా నిర్వచించబడిందని మనం చూస్తాము. ప్యూమా అనేది రూబీలో వ్రాయబడిన సేవ. రెండవ సందర్భంలో మేము భర్తీ చేస్తాము. ఈ ఆదేశం మన అవసరాలు లేదా పనులను బట్టి ఏకపక్షంగా ఉండవచ్చు.

మేము మా డెవలపర్ హోస్ట్ మెషీన్‌లోని పోర్ట్‌ను 3000 నుండి 3000 కంటైనర్ పోర్ట్‌కు ఫార్వార్డ్ చేయాల్సిన అవసరం ఉందని కూడా మేము వివరించాము. ఇది iptables మరియు దాని స్వంత యంత్రాంగాన్ని ఉపయోగించి స్వయంచాలకంగా చేయబడుతుంది, ఇది నేరుగా డాకర్‌లో పొందుపరచబడింది.

డెవలపర్ మునుపటిలాగా, అందుబాటులో ఉన్న ఏదైనా IP చిరునామాను యాక్సెస్ చేయవచ్చు, ఉదాహరణకు, మెషీన్ యొక్క 127.0.0.1 స్థానిక లేదా బాహ్య IP చిరునామా.

వెబ్ కంటైనర్ db కంటైనర్‌పై ఆధారపడి ఉంటుందని చివరి పంక్తి చెబుతుంది. మేము లాంచ్ చేయడానికి వెబ్ కంటైనర్‌కు కాల్ చేసినప్పుడు, డాకర్-కంపోజ్ మొదట మన కోసం డేటాబేస్‌ను ప్రారంభిస్తుంది. ఇప్పటికే డేటాబేస్ ప్రారంభంలో (వాస్తవానికి, కంటైనర్ ప్రారంభించిన తర్వాత! ఇది డేటాబేస్ యొక్క సంసిద్ధతకు హామీ ఇవ్వదు) ఇది మా అప్లికేషన్, మా బ్యాకెండ్‌ను ప్రారంభిస్తుంది.

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

ప్రాజెక్ట్‌లో డేటాబేస్ డాకరైజేషన్‌ని ఉపయోగించడం మనకు ఏమి ఇస్తుంది? మేము డెవలపర్‌లందరి కోసం MySQL సంస్కరణను రికార్డ్ చేస్తాము. సంస్కరణలు వేరు చేయబడినప్పుడు, సింటాక్స్, కాన్ఫిగరేషన్ మరియు డిఫాల్ట్ సెట్టింగ్‌లు మారినప్పుడు సంభవించే కొన్ని లోపాలను నివారించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది. ఇది డేటాబేస్, లాగిన్, పాస్‌వర్డ్ కోసం సాధారణ హోస్ట్ పేరును పేర్కొనడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇంతకు ముందు ఉన్న కాన్ఫిగర్ ఫైల్‌లలో పేర్లు మరియు వైరుధ్యాల జూ నుండి మేము దూరంగా ఉన్నాము.

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

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

చిత్రాన్ని నిర్మించిన తర్వాత, డెవలప్‌మెంట్ మరియు ప్రొడక్షన్ రెండింటిలోనూ కంటైనర్‌లు ఒకే విధంగా ఉంటాయి. పెద్ద సంస్థాపనలకు ఇది ప్రత్యేకంగా వర్తిస్తుంది.

ఫ్రంటెండ్‌లో మేము JavaScipt మరియు NodeJSలను ఉపయోగిస్తాము.

ఇప్పుడు ReacJSలో మా చివరి ప్రాజెక్ట్ ఉంది. డెవలపర్ కంటైనర్‌లోని ప్రతిదాన్ని ప్రారంభించాడు మరియు హాట్-రీలోడ్‌ని ఉపయోగించి అభివృద్ధి చేశాడు.

తరువాత, JavaSciptని అసెంబ్లింగ్ చేసే పని ప్రారంభించబడింది మరియు స్థిరంగా అసెంబుల్ చేయబడిన కోడ్ nginx ద్వారా పంపబడుతుంది, వనరులను ఆదా చేస్తుంది.

ఇక్కడ నేను మా తాజా ప్రాజెక్ట్ యొక్క రేఖాచిత్రాన్ని అందించాను.

మీరు ఏ సమస్యలను పరిష్కరించారు? మొబైల్ పరికరాలు ఇంటరాక్ట్ అయ్యే సిస్టమ్‌ను రూపొందించాల్సిన అవసరం మాకు ఉంది. వారు డేటాను స్వీకరిస్తారు. ఈ పరికరానికి పుష్ నోటిఫికేషన్‌లను పంపడం అనేది అవకాశాలలో ఒకటి.

దీని కోసం మనం ఏమి చేసాము?

మేము అప్లికేషన్‌ను క్రింది భాగాలుగా విభజించాము: JSలో నిర్వాహక భాగం, రూబీ ఆన్ రైల్స్ కింద REST ఇంటర్‌ఫేస్ ద్వారా పనిచేసే బ్యాకెండ్. బ్యాకెండ్ డేటాబేస్తో పరస్పర చర్య చేస్తుంది. ఉత్పత్తి చేయబడిన ఫలితం క్లయింట్‌కు ఇవ్వబడుతుంది. నిర్వాహక పానెల్ REST ఇంటర్‌ఫేస్ ద్వారా బ్యాకెండ్ మరియు డేటాబేస్‌తో పరస్పర చర్య చేస్తుంది.

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

మేము ఈ క్రింది పథకాన్ని అభివృద్ధి చేసాము: బ్రౌజర్ నుండి ఆపరేటర్ నిర్వాహక పానెల్‌తో సంకర్షణ చెందుతుంది, నిర్వాహక ప్యానెల్ బ్యాకెండ్‌తో పరస్పర చర్య చేస్తుంది, పని పుష్ నోటిఫికేషన్‌లను పంపడం.

NodeJSలో అమలు చేయబడిన మరొక భాగంతో పుష్ నోటిఫికేషన్‌లు పరస్పర చర్య చేస్తాయి.

క్యూలు నిర్మించబడ్డాయి మరియు వారి స్వంత యంత్రాంగం ప్రకారం నోటిఫికేషన్‌లు పంపబడతాయి.

రెండు డేటాబేస్‌లు ఇక్కడ డ్రా చేయబడ్డాయి. ప్రస్తుతం, డాకర్‌ని ఉపయోగించి, మేము 2 స్వతంత్ర డేటాబేస్‌లను ఉపయోగిస్తాము, అవి ఒకదానికొకటి కనెక్ట్ చేయబడవు. వారు సాధారణ వర్చువల్ నెట్‌వర్క్‌ను కలిగి ఉన్నారనే వాస్తవంతో పాటు, భౌతిక డేటా డెవలపర్ మెషీన్‌లోని వివిధ డైరెక్టరీలలో నిల్వ చేయబడుతుంది.

అదే విషయం కానీ సంఖ్యలో. కోడ్ పునర్వినియోగం ఇక్కడ ముఖ్యమైనది.

ఇంతకుముందు మేము లైబ్రరీల రూపంలో కోడ్‌ను తిరిగి ఉపయోగించడం గురించి మాట్లాడినట్లయితే, ఈ ఉదాహరణలో పుష్ నోటిఫికేషన్‌లకు ప్రతిస్పందించే మా సేవ పూర్తి సర్వర్‌గా తిరిగి ఉపయోగించబడుతుంది. ఇది APIని అందిస్తుంది. మరియు మా కొత్త అభివృద్ధి దానితో సంకర్షణ చెందుతుంది.

ఆ సమయంలో మేము NodeJS వెర్షన్ 4ని ఉపయోగిస్తున్నాము. ఇప్పుడు (2017లో - ఎడిటర్స్ నోట్) మా తాజా డెవలప్‌మెంట్‌లలో మేము NodeJS వెర్షన్ 7ని ఉపయోగిస్తాము. లైబ్రరీల యొక్క కొత్త సంస్కరణలను చేర్చడానికి కొత్త భాగాలలో సమస్య లేదు.

అవసరమైతే, మీరు పుష్ నోటిఫికేషన్ సేవ యొక్క NodeJS సంస్కరణను రీఫ్యాక్టర్ చేయవచ్చు మరియు పెంచవచ్చు.

మరియు మేము API అనుకూలతను నిర్వహించగలిగితే, దానిని గతంలో ఉపయోగించిన ఇతర ప్రాజెక్ట్‌లతో భర్తీ చేయడం సాధ్యమవుతుంది.

డాకర్‌ని జోడించడానికి మీరు ఏమి చేయాలి? మేము మా రిపోజిటరీకి డాకర్‌ఫైల్‌ని జోడిస్తాము, ఇది అవసరమైన డిపెండెన్సీలను వివరిస్తుంది. ఈ ఉదాహరణలో, భాగాలు తార్కికంగా విభజించబడ్డాయి. బ్యాకెండ్ డెవలపర్‌కి ఇది కనీస కిట్.

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

స్టాటిక్ కంటెంట్‌ను అందించడానికి మేము nginxతో ప్రత్యేక మూడవ కంటైనర్‌ను ఉపయోగిస్తాము. చిత్రాలను అప్‌లోడ్ చేయడం సాధ్యపడుతుంది. బ్యాకెండ్ వాటిని ముందుగా సిద్ధం చేసిన వాల్యూమ్‌లో ఉంచుతుంది, ఇది స్టాటిక్ డేటాను అందించే nginxతో కూడిన కంటైనర్‌లో కూడా అమర్చబడుతుంది.

nginx మరియు mysql కాన్ఫిగరేషన్‌ను నిల్వ చేయడానికి, మేము అవసరమైన కాన్ఫిగరేషన్‌లను నిల్వ చేసే డాకర్ ఫోల్డర్‌ను జోడించాము. డెవలపర్ తన మెషీన్‌లో రిపోజిటరీ యొక్క జిట్ క్లోన్‌ను రూపొందించినప్పుడు, అతను ఇప్పటికే స్థానిక అభివృద్ధి కోసం సిద్ధంగా ఉన్న ప్రాజెక్ట్‌ని కలిగి ఉన్నాడు. ఏ పోర్ట్ లేదా ఏ సెట్టింగ్‌లను వర్తింపజేయాలనే దాని గురించి ప్రశ్న లేదు.

తర్వాత మనకు అనేక భాగాలు ఉన్నాయి: అడ్మిన్, ఇన్ఫో-API, పుష్ నోటిఫికేషన్‌లు.

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

ఇది డాకరైజ్డ్-యాప్ కంటెంట్‌లకు ఉదాహరణ. మేము ఇక్కడ డాకర్ డైరెక్టరీని కూడా ఉంచుతాము, దీనిలో మేము అన్ని భాగాల పరస్పర చర్యలకు అవసరమైన కాన్ఫిగరేషన్‌లను పూరించాము. ప్రాజెక్ట్‌ను ఎలా ప్రారంభించాలో క్లుప్తంగా వివరించే README.md ఉంది.

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

పుష్ నోటిఫికేషన్‌లతో ఏకీకరణ అవసరం ఉన్నట్లయితే, అప్పుడు docker-compose.yaml మరియు docker-compose-push.yaml ప్రారంభించబడతాయి.

docker-compose.yaml మరియు docker-compose-push.yaml ఫోల్డర్‌లో ఉన్నందున, ఒకే వర్చువల్ నెట్‌వర్క్ స్వయంచాలకంగా సృష్టించబడుతుంది.

భాగాల వివరణ. ఇది భాగాలను సేకరించే బాధ్యత కలిగిన మరింత అధునాతన ఫైల్. ఇక్కడ విశేషమైనది ఏమిటి? ఇక్కడ మనం బాలన్సర్ కాంపోనెంట్‌ని పరిచయం చేస్తున్నాము.

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

అభివృద్ధి వాతావరణం కోసం మేము .dev డొమైన్‌ని ఉపయోగిస్తాము - api.informer.dev. డెవలపర్ స్థానిక మెషీన్‌లో .dev డొమైన్‌తో అప్లికేషన్‌లు అందుబాటులో ఉన్నాయి.

అప్పుడు కాన్ఫిగరేషన్‌లు ప్రతి ప్రాజెక్ట్‌కు బదిలీ చేయబడతాయి మరియు అన్ని ప్రాజెక్ట్‌లు ఒకే సమయంలో కలిసి ప్రారంభించబడతాయి.

మేము దానిని గ్రాఫికల్‌గా చిత్రీకరిస్తే, క్లయింట్ మా బ్రౌజర్ లేదా బ్యాలెన్సర్‌కు అభ్యర్థనలు చేసే ఒక రకమైన సాధనం అని తేలింది.

డొమైన్ పేరు ఆధారంగా ఏ కంటైనర్‌ను యాక్సెస్ చేయాలో బాలన్సర్ నిర్ణయిస్తుంది.

ఇది nginx కావచ్చు, ఇది అడ్మిన్ ప్యానెల్‌కు JSని అందిస్తుంది. ఇది APIని అందించే nginx నుండి కావచ్చు లేదా చిత్రాలను డౌన్‌లోడ్ చేసే రూపంలో nginxకి అందించబడే స్టాటిక్ ఫైల్‌లు కావచ్చు.

కంటైనర్‌లు వర్చువల్ నెట్‌వర్క్‌కు కనెక్ట్ చేయబడి, ప్రాక్సీ వెనుక దాగి ఉన్నాయని రేఖాచిత్రం చూపుతుంది.

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

నా దరఖాస్తును డాకరైజ్ చేయడానికి నేను ఏ ఉదాహరణను చూడాలి? నా అభిప్రాయం ప్రకారం, MySQL కోసం అధికారిక డాకర్ చిత్రం మంచి ఉదాహరణ.

ఇది చాలా సంక్లిష్టమైనది. అనేక వెర్షన్లు ఉన్నాయి. కానీ దాని కార్యాచరణ మరింత అభివృద్ధి ప్రక్రియలో ఉత్పన్నమయ్యే అనేక అవసరాలను కవర్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు సమయాన్ని వెచ్చించి, అవన్నీ ఎలా సంకర్షణ చెందుతాయో అర్థం చేసుకుంటే, దాన్ని మీరే అమలు చేయడంలో మీకు ఎలాంటి సమస్యలు ఉండవని నేను భావిస్తున్నాను.

Hub.docker.com సాధారణంగా github.comకి లింక్‌లను కలిగి ఉంటుంది, ఇక్కడ ముడి డేటా నేరుగా అందించబడుతుంది, దాని నుండి మీరు మీరే చిత్రాన్ని రూపొందించుకోవచ్చు.

ఇంకా ఈ రిపోజిటరీలో స్క్రిప్ట్ docker-endpoint.sh ఉంది, ఇది అప్లికేషన్ లాంచ్ యొక్క ప్రారంభ ప్రారంభానికి మరియు తదుపరి ప్రాసెసింగ్‌కు బాధ్యత వహిస్తుంది.

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

యాదృచ్ఛిక పాస్వర్డ్ను సృష్టించడానికి ఒక ఎంపిక ఉంది. మనకు వినియోగదారు కావాలి, వినియోగదారు కోసం పాస్‌వర్డ్ సెట్ చేయాలి మరియు మేము డేటాబేస్ సృష్టించాలి అని మేము చెబుతున్నాము.

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

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

docker-endpoint.sh స్క్రిప్ట్ ఎంట్రీ పాయింట్‌కు బాధ్యత వహిస్తుంది. ప్రారంభ ప్రారంభ సమయంలో, కొన్ని తయారీ చర్యలు అవసరం మరియు ఈ చర్యలన్నీ ప్రారంభ స్క్రిప్ట్‌లో చేర్చబడతాయి.

ఇక రెండో భాగానికి వెళ్దాం.

సోర్స్ కోడ్‌లను స్టోర్ చేయడానికి మేము గిట్‌లాబ్‌కి మారాము. ఇది విజువల్ ఇంటర్‌ఫేస్‌ని కలిగి ఉన్న చాలా శక్తివంతమైన సిస్టమ్.

Gitlab భాగాలలో ఒకటి Gitlab CI. కోడ్ డెలివరీ సిస్టమ్‌ను నిర్వహించడానికి లేదా ఆటోమేటెడ్ టెస్టింగ్‌ని అమలు చేయడానికి తదనంతరం ఉపయోగించబడే ఆదేశాల శ్రేణిని వివరించడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది.

Gitlab CI 2పై నివేదిక https://goo.gl/uohKjI - రూబీ రష్యా క్లబ్ నుండి వచ్చిన నివేదిక చాలా వివరంగా ఉంది మరియు మీకు ఆసక్తి కలిగి ఉండవచ్చు.

ఇప్పుడు మనం Gitlab CIని సక్రియం చేయడానికి ఏమి అవసరమో చూద్దాం. Gitlab CIని ప్రారంభించడానికి, మేము ప్రాజెక్ట్ యొక్క రూట్‌లో .gitlab-ci.yml ఫైల్‌ను ఉంచాలి.

మేము పరీక్ష, విస్తరణ వంటి రాష్ట్రాల క్రమాన్ని నిర్వహించాలనుకుంటున్నామని ఇక్కడ వివరించాము.

మేము మా అప్లికేషన్ యొక్క డాకర్-కంపోజ్ బిల్డ్‌ని నేరుగా పిలిచే స్క్రిప్ట్‌లను అమలు చేస్తాము. ఇది కేవలం బ్యాకెండ్‌కి ఉదాహరణ.

డేటాబేస్‌ను మార్చడానికి మరియు పరీక్షలను అమలు చేయడానికి మైగ్రేషన్‌లను అమలు చేయడం అవసరమని మేము తరువాత చెబుతున్నాము.

స్క్రిప్ట్‌లు సరిగ్గా అమలు చేయబడి, లోపం కోడ్‌ను తిరిగి ఇవ్వకపోతే, సిస్టమ్ విస్తరణ యొక్క రెండవ దశకు వెళుతుంది.

ప్రస్తుతం స్టేజింగ్ కోసం విస్తరణ దశ అమలు చేయబడింది. మేము నో-డౌన్‌టైమ్ రీస్టార్ట్‌ను నిర్వహించలేదు.

మేము అన్ని కంటైనర్లను బలవంతంగా ఆర్పివేస్తాము, ఆపై మేము అన్ని కంటైనర్లను మళ్లీ పెంచుతాము, పరీక్ష సమయంలో మొదటి దశలో సేకరించాము.

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

ఇది మాస్టర్ బ్రాంచ్‌కు మాత్రమే వర్తింపజేయాలని ఒక గమనిక ఉంది.

ఇతర శాఖలను మార్చేటప్పుడు పని చేయదు.

శాఖల వెంట రోల్‌అవుట్‌లను నిర్వహించడం సాధ్యమవుతుంది.

దీన్ని మరింత నిర్వహించడానికి, మేము Gitlab రన్నర్‌ని ఇన్‌స్టాల్ చేయాలి.

ఈ యుటిలిటీ గోలాంగ్‌లో వ్రాయబడింది. ఇది గోలాంగ్ ప్రపంచంలో సాధారణంగా ఉండే ఒకే ఫైల్, దీనికి ఎలాంటి డిపెండెన్సీలు అవసరం లేదు.

ప్రారంభంలో మేము Gitlab రన్నర్‌ను నమోదు చేస్తాము.

మేము Gitlab వెబ్ ఇంటర్‌ఫేస్‌లో కీని స్వీకరిస్తాము.

అప్పుడు మేము కమాండ్ లైన్‌లో ప్రారంభ ఆదేశాన్ని పిలుస్తాము.

Gitlab రన్నర్‌ని డైలాగ్ మోడ్‌లో కాన్ఫిగర్ చేస్తోంది (షెల్, డాకర్, వర్చువల్‌బాక్స్, SSH)

Gitlab రన్నర్‌లోని కోడ్ .gitlab-ci.yml సెట్టింగ్‌పై ఆధారపడి ప్రతి కమిట్‌లో అమలు చేయబడుతుంది.

వెబ్ ఇంటర్‌ఫేస్‌లోని గిట్‌లాబ్‌లో ఇది దృశ్యమానంగా ఎలా కనిపిస్తుంది. GITlab CIని కనెక్ట్ చేసిన తర్వాత, బిల్డ్ ప్రస్తుతం ఏ స్థితిలో ఉందో చూపే ఫ్లాగ్ మా వద్ద ఉంది.

మేము 4 నిమిషాల క్రితం అన్ని పరీక్షలలో ఉత్తీర్ణత సాధించి, ఎటువంటి సమస్యలను కలిగించకుండా ఒక కమిట్ చేయబడటం చూస్తాము.

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

మేము నిర్దిష్ట బిల్డ్‌పై క్లిక్ చేస్తే, .gitlab-ci.yml ప్రకారం ప్రాసెస్‌లో ప్రారంభించబడిన ఆదేశాల కన్సోల్ అవుట్‌పుట్ ఉంటుంది.

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

మేము డాకర్‌ని అమలు చేసినప్పుడు స్టేజింగ్‌లో ఏ సమస్యలను పరిష్కరించాము? మా సిస్టమ్ భాగాలను కలిగి ఉంటుంది మరియు మేము రిపోజిటరీలో నవీకరించబడిన కొన్ని భాగాలను మాత్రమే పునఃప్రారంభించవలసి ఉంటుంది మరియు మొత్తం సిస్టమ్ కాదు.

దీన్ని చేయడానికి, మేము అన్నింటినీ ప్రత్యేక ఫోల్డర్‌లుగా విభజించాలి.

మేము దీన్ని చేసిన తర్వాత, ప్రతి ఫోల్డర్‌కు డాకర్-కంపోజ్ దాని స్వంత నెట్‌వర్క్ స్థలాన్ని సృష్టిస్తుంది మరియు దాని పొరుగువారి భాగాలను చూడదు అనే వాస్తవంతో మాకు సమస్య ఉంది.

చుట్టూ తిరగడానికి, మేము డాకర్‌లో మాన్యువల్‌గా నెట్‌వర్క్‌ని సృష్టించాము. డాకర్-కంపోజ్‌లో మీరు ఈ ప్రాజెక్ట్ కోసం అలాంటి నెట్‌వర్క్‌ని ఉపయోగించాలని వ్రాయబడింది.

ఈ విధంగా, ఈ మెష్‌తో ప్రారంభమయ్యే ప్రతి భాగం సిస్టమ్‌లోని ఇతర భాగాలలోని భాగాలను చూస్తుంది.

తదుపరి సమస్య అనేక ప్రాజెక్టుల మధ్య స్టేజింగ్‌ను విభజించడం.

ఇవన్నీ అందంగా కనిపించడానికి మరియు ఉత్పత్తికి వీలైనంత దగ్గరగా ఉండటానికి, వెబ్‌లో ప్రతిచోటా ఉపయోగించే పోర్ట్ 80 లేదా 443ని ఉపయోగించడం మంచిది.

మేము దీన్ని ఎలా పరిష్కరించాము? మేము అన్ని పెద్ద ప్రాజెక్ట్‌లకు ఒక గిట్లాబ్ రన్నర్‌ని కేటాయించాము.

అనేక పంపిణీ చేయబడిన గిట్‌లాబ్ రన్నర్‌లను ప్రారంభించేందుకు Gitlab మిమ్మల్ని అనుమతిస్తుంది, ఇది అన్ని టాస్క్‌లను ఒక్కొక్కటిగా అస్తవ్యస్తమైన క్రమంలో తీసుకొని వాటిని అమలు చేస్తుంది.

గృహ సమస్యలను నివారించడానికి, మేము మా ప్రాజెక్ట్‌ల సమూహాన్ని ఒక గిట్‌లాబ్ రన్నర్‌కు పరిమితం చేసాము, ఇది సమస్యలు లేకుండా మా వాల్యూమ్‌లను ఎదుర్కొంటుంది.

మేము nginx-proxyని ప్రత్యేక లాంచ్ స్క్రిప్ట్‌లోకి తరలించాము మరియు దానిలో అన్ని ప్రాజెక్ట్‌ల గ్రిడ్‌లను వ్రాసాము.

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

మా అభ్యర్థనలు పోర్ట్ 80లోని డొమైన్ ద్వారా వస్తాయి మరియు ఈ డొమైన్‌ను అందించే కంటైనర్‌ల సమూహానికి పరిష్కరించబడతాయి.

ఏ ఇతర సమస్యలు ఉన్నాయి? ఇది డిఫాల్ట్‌గా అన్ని కంటైనర్‌లు రూట్‌గా నడుస్తుంది. ఇది సిస్టమ్ యొక్క మూల అసమాన రూట్ హోస్ట్.

అయితే, మీరు కంటైనర్‌ను నమోదు చేస్తే, అది రూట్ అవుతుంది మరియు ఈ కంటైనర్‌లో మనం సృష్టించే ఫైల్ రూట్ హక్కులను పొందుతుంది.

ఒక డెవలపర్ కంటైనర్‌లోకి ప్రవేశించి, ఫైల్‌లను రూపొందించే కొన్ని ఆదేశాలను అక్కడ చేస్తే, ఆపై కంటైనర్‌ను వదిలివేసినట్లయితే, అతని వర్కింగ్ డైరెక్టరీలో అతనికి యాక్సెస్ లేని ఫైల్ ఉంది.

దీన్ని ఎలా పరిష్కరించవచ్చు? మీరు కంటైనర్‌లో ఉండే వినియోగదారులను జోడించవచ్చు.

మేము వినియోగదారుని జోడించినప్పుడు ఏ సమస్యలు తలెత్తాయి?

వినియోగదారుని సృష్టించేటప్పుడు, సమూహం ID (UID) మరియు వినియోగదారు ID (GID) తరచుగా సరిపోలడం లేదు.

కంటైనర్‌లో ఈ సమస్యను పరిష్కరించడానికి మేము ID 1000 ఉన్న వినియోగదారులను ఉపయోగిస్తాము.

మా విషయంలో, దాదాపు అందరు డెవలపర్లు ఉబుంటు OSని ఉపయోగిస్తున్నారనే వాస్తవంతో ఇది ఏకీభవించింది. మరియు ఉబుంటు OSలో మొదటి వినియోగదారుకు ID 1000 ఉంటుంది.

మాకు ప్రణాళికలు ఉన్నాయా?

డాకర్ డాక్యుమెంటేషన్‌ను మళ్లీ చదవండి. ప్రాజెక్ట్ చురుకుగా అభివృద్ధి చెందుతోంది, డాక్యుమెంటేషన్ మారుతోంది. రెండు మూడు నెలల క్రితం లభించిన డేటా మెల్లమెల్లగా పాతబడిపోతోంది.

మేము పరిష్కరించిన కొన్ని సమస్యలు ఇప్పటికే ప్రామాణిక మార్గాల ద్వారా పరిష్కరించబడి ఉండవచ్చు.

నేను నిజంగా ముందుకు సాగాలనుకుంటున్నాను మరియు నేరుగా ఆర్కెస్ట్రేషన్‌కు వెళ్లాలనుకుంటున్నాను.

ఒక ఉదాహరణ డాకర్ యొక్క అంతర్నిర్మిత మెకానిజం డాకర్ స్వార్మ్ అని పిలువబడుతుంది, ఇది బాక్స్ నుండి బయటకు వస్తుంది. నేను డాకర్ స్వార్మ్ టెక్నాలజీ ఆధారంగా ఏదైనా ఉత్పత్తిని ప్రారంభించాలనుకుంటున్నాను.

స్పాన్నింగ్ కంటైనర్లు లాగ్‌లతో పని చేయడం అసౌకర్యంగా ఉంటుంది. ఇప్పుడు లాగ్‌లు వేరుచేయబడ్డాయి. అవి కంటైనర్లలో చెల్లాచెదురుగా ఉన్నాయి. వెబ్ ఇంటర్‌ఫేస్ ద్వారా లాగ్‌లకు అనుకూలమైన యాక్సెస్‌ను చేయడం టాస్క్‌లలో ఒకటి.

మూలం: www.habr.com