డాకర్ అంటే ఏమిటి: చరిత్ర మరియు ప్రాథమిక సారాంశాలలో సంక్షిప్త విహారం

స్లర్మ్‌లో ఆగస్టు 10న ప్రారంభమైంది డాకర్ వీడియో కోర్సు, దీనిలో మేము పూర్తిగా విశ్లేషిస్తాము - ప్రాథమిక సంగ్రహాల నుండి నెట్‌వర్క్ పారామితుల వరకు.

ఈ వ్యాసంలో మేము డాకర్ చరిత్ర మరియు దాని ప్రధాన సంగ్రహాల గురించి మాట్లాడుతాము: చిత్రం, క్లి, డాకర్‌ఫైల్. ఉపన్యాసం ప్రారంభకులకు ఉద్దేశించబడింది, కాబట్టి ఇది అనుభవజ్ఞులైన వినియోగదారులకు ఆసక్తిని కలిగించే అవకాశం లేదు. రక్తం, అనుబంధం లేదా లోతైన ఇమ్మర్షన్ ఉండదు. చాలా ప్రాథమిక అంశాలు.

డాకర్ అంటే ఏమిటి

వికీపీడియా నుండి డాకర్ యొక్క నిర్వచనాన్ని చూద్దాం.

డాకర్ అనేది కంటెయినరైజ్డ్ పరిసరాలలో అప్లికేషన్‌ల విస్తరణ మరియు నిర్వహణను ఆటోమేట్ చేయడానికి సాఫ్ట్‌వేర్.

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

ఏకశిలా యుగం

ఏకశిలా యుగం అనేది 2000ల ప్రారంభంలో, అన్ని అప్లికేషన్‌లు ఏకశిలాగా, అనేక డిపెండెన్సీలతో ఉంటాయి. అభివృద్ధికి చాలా సమయం పట్టింది. అదే సమయంలో, చాలా సర్వర్లు లేవు; మనమందరం వాటిని పేరు ద్వారా తెలుసు మరియు వాటిని పర్యవేక్షించాము. అటువంటి ఫన్నీ పోలిక ఉంది:

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

హైపర్‌వైజర్ ఆధారిత వర్చువలైజేషన్ సిస్టమ్స్

ప్రతి ఒక్కరూ వర్చువలైజేషన్ సిస్టమ్‌ల గురించి బహుశా విని ఉంటారు: VMware, VirtualBox, Hyper-V, Qemu KVM, మొదలైనవి. అవి అప్లికేషన్ ఐసోలేషన్ మరియు రిసోర్స్ మేనేజ్‌మెంట్‌ను అందిస్తాయి, అయితే వాటికి ప్రతికూలతలు కూడా ఉన్నాయి. వర్చువలైజేషన్ చేయడానికి, మీకు హైపర్‌వైజర్ అవసరం. మరియు హైపర్‌వైజర్ అనేది రిసోర్స్ ఓవర్ హెడ్. మరియు వర్చువల్ మెషీన్ సాధారణంగా మొత్తం కోలోసస్ - ఆపరేటింగ్ సిస్టమ్, Nginx, Apache మరియు బహుశా MySQLని కలిగి ఉన్న భారీ చిత్రం. చిత్రం పెద్దది మరియు వర్చువల్ మిషన్ ఆపరేట్ చేయడానికి అసౌకర్యంగా ఉంది. ఫలితంగా, వర్చువల్ మిషన్లతో పని చేయడం నెమ్మదిగా ఉంటుంది. ఈ సమస్యను పరిష్కరించడానికి, కెర్నల్ స్థాయిలో వర్చువలైజేషన్ సిస్టమ్‌లు సృష్టించబడ్డాయి.

కెర్నల్-స్థాయి వర్చువలైజేషన్ సిస్టమ్స్

కెర్నల్-స్థాయి వర్చువలైజేషన్‌కు OpenVZ, Systemd-nspawn, LXC సిస్టమ్‌లు మద్దతు ఇస్తున్నాయి. అటువంటి వర్చువలైజేషన్ యొక్క అద్భుతమైన ఉదాహరణ LXC (Linux కంటైనర్లు).

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

ముఖ్యంగా LXC కంటైనర్‌లను సృష్టిస్తుంది. వర్చువల్ మిషన్లు మరియు కంటైనర్ల మధ్య తేడా ఏమిటి?

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

వర్చువలైజేషన్ మరియు కంటైనర్ల మధ్య తేడాలు రేఖాచిత్రంలో చూడవచ్చు.
హార్డ్‌వేర్ హైపర్‌వైజర్‌లు, OS పైన హైపర్‌వైజర్‌లు మరియు కంటైనర్‌లు ఉన్నాయి.

మీరు నిజంగా ఏదైనా వేరు చేయాలనుకుంటే హార్డ్‌వేర్ హైపర్‌వైజర్‌లు బాగుంటాయి. ఎందుకంటే మెమరీ పేజీలు మరియు ప్రాసెసర్ల స్థాయిలో వేరుచేయడం సాధ్యమవుతుంది.

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

కెర్నల్ స్థాయిలో కంటెయినరైజేషన్ కోసం ఏది ఉపయోగించబడుతుంది

ఇతర ప్రక్రియల నుండి వేరుచేయబడిన కంటైనర్‌ను సృష్టించడానికి మిమ్మల్ని అనుమతించే ప్రధాన సాంకేతికతలు నేమ్‌స్పేస్‌లు మరియు నియంత్రణ సమూహాలు.

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

PID నేమ్‌స్పేస్ ప్రక్రియలను పరిమితం చేస్తుంది. ఉదాహరణకు, మేము PID నేమ్‌స్పేస్‌ని సృష్టించి, అక్కడ ప్రాసెస్‌ను ఉంచినప్పుడు, అది PID 1తో మారుతుంది. సాధారణంగా సిస్టమ్‌లలో PID 1 అనేది systemd లేదా init. దీని ప్రకారం, మనం ఒక ప్రాసెస్‌ను కొత్త నేమ్‌స్పేస్‌లో ఉంచినప్పుడు, అది PID 1ని కూడా అందుకుంటుంది.

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

నియంత్రణ సమూహాలు: మెమరీ, CPU, IOPS, నెట్‌వర్క్ - మొత్తం 12 సెట్టింగ్‌లు. లేకపోతే వాటిని Cgroups (“C-groups”) అని కూడా అంటారు.

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

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

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

కాపీ-ఆన్-రైట్ సిస్టమ్ డాకర్ చిత్రాలతో పని చేయడానికి మరియు వాటిని మరింత సమర్థవంతంగా ఉపయోగించడానికి అనుమతిస్తుంది.

డాకర్ ప్రస్తుతం Cgroups v2తో అనుకూలత సమస్యలను కలిగి ఉంది, కాబట్టి ఈ కథనం Cgroups v1పై ప్రత్యేకంగా దృష్టి సారిస్తుంది.

అయితే చరిత్రకు తిరిగి వద్దాం.

వర్చువలైజేషన్ సిస్టమ్స్ కెర్నల్ స్థాయిలో కనిపించినప్పుడు, అవి చురుకుగా ఉపయోగించడం ప్రారంభించాయి. హైపర్‌వైజర్‌పై ఓవర్‌హెడ్ అదృశ్యమైంది, అయితే కొన్ని సమస్యలు అలాగే ఉన్నాయి:

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

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

కంటైనర్ యుగం

కంటైనర్ల యుగం వచ్చినప్పుడు, వారితో పనిచేసే తత్వశాస్త్రం మారిపోయింది:

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

పెంపుడు జంతువులు vs పశువుల గురించి నేను చెప్పినట్లు గుర్తుందా? ఇంతకుముందు పెంపుడు జంతువుల్లా ఉండే ఉదంతాలు ఇప్పుడు పశువుల్లా మారాయి. గతంలో, ఒక ఏకశిలా ఉంది - ఒక అప్లికేషన్. ఇప్పుడు అది 100 మైక్రో సర్వీసెస్, 100 కంటైనర్లు. కొన్ని కంటైనర్లు 2-3 ప్రతిరూపాలను కలిగి ఉండవచ్చు. ప్రతి కంటైనర్‌ను నియంత్రించడం మాకు తక్కువ ముఖ్యం. సేవ యొక్క లభ్యత మాకు మరింత ముఖ్యమైనది: ఈ కంటైనర్ల సెట్ ఏమి చేస్తుంది. ఇది పర్యవేక్షణకు సంబంధించిన విధానాలను మారుస్తుంది.

2014-2015లో, డాకర్ అభివృద్ధి చెందింది - ఇప్పుడు మనం మాట్లాడే సాంకేతికత.

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

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

ఓవర్ హెడ్ గురించి డైగ్రెషన్

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

మరోవైపు, మీరు లోతుగా వెళితే, నిజానికి డాకర్‌లో అనేక విషయాలు ఉన్నాయి, వీటిని ఒక స్ట్రెచ్‌తో ఓవర్‌హెడ్ అని చెప్పవచ్చు.

మొదటిది PID నేమ్‌స్పేస్. మేము నేమ్‌స్పేస్‌లో ప్రాసెస్‌ను ఉంచినప్పుడు, దానికి PID 1 కేటాయించబడుతుంది. అదే సమయంలో, ఈ ప్రాసెస్‌లో మరొక PID ఉంటుంది, ఇది కంటైనర్ వెలుపల హోస్ట్ నేమ్‌స్పేస్‌లో ఉంటుంది. ఉదాహరణకు, మేము Nginxని కంటైనర్‌లో ప్రారంభించాము, అది PID 1 (మాస్టర్ ప్రాసెస్)గా మారింది. మరియు హోస్ట్‌లో దీనికి PID 12623 ఉంది. మరియు అది ఎంత ఓవర్‌హెడ్ అని చెప్పడం కష్టం.

రెండవ విషయం Cgroups. మెమరీ ద్వారా Cgroups తీసుకుందాం, అంటే కంటైనర్ మెమరీని పరిమితం చేసే సామర్థ్యం. ఇది ప్రారంభించబడినప్పుడు, కౌంటర్లు మరియు మెమరీ అకౌంటింగ్ సక్రియం చేయబడతాయి: ఈ కంటైనర్‌కు ఎన్ని పేజీలు కేటాయించబడ్డాయి మరియు ఎన్ని ఇప్పటికీ ఉచితం అని కెర్నల్ అర్థం చేసుకోవాలి. ఇది బహుశా ఓవర్‌హెడ్ కావచ్చు, కానీ ఇది పనితీరును ఎలా ప్రభావితం చేస్తుందనే దానిపై ఖచ్చితమైన అధ్యయనాలు నేను చూడలేదు. మరియు డాకర్‌లో నడుస్తున్న అప్లికేషన్ అకస్మాత్తుగా పనితీరులో తీవ్ర నష్టాన్ని అనుభవించిందని నేను గమనించలేదు.

మరియు పనితీరు గురించి మరొక గమనిక. కొన్ని కెర్నల్ పారామితులు హోస్ట్ నుండి కంటైనర్‌కు పంపబడతాయి. ముఖ్యంగా, కొన్ని నెట్వర్క్ పారామితులు. అందువల్ల, మీరు డాకర్‌లో ఏదైనా అధిక-పనితీరును అమలు చేయాలనుకుంటే, ఉదాహరణకు నెట్‌వర్క్‌ను చురుకుగా ఉపయోగించేది, అప్పుడు మీరు కనీసం ఈ పారామితులను సర్దుబాటు చేయాలి. కొన్ని nf_conntrack, ఉదాహరణకు.

డాకర్ కాన్సెప్ట్ గురించి

డాకర్ అనేక భాగాలను కలిగి ఉంటుంది:

1. డాకర్ డెమోన్ అదే కంటైనర్ ఇంజిన్; కంటైనర్లను ప్రయోగిస్తుంది.
2. డాకర్ CII అనేది డాకర్ మేనేజ్‌మెంట్ యుటిలిటీ.
3. డాకర్‌ఫైల్ - చిత్రాన్ని ఎలా నిర్మించాలో సూచనలు.
4. చిత్రం - కంటైనర్‌ను బయటకు తీసిన చిత్రం.
5. కంటైనర్.
6. డాకర్ రిజిస్ట్రీ అనేది ఇమేజ్ రిపోజిటరీ.

క్రమపద్ధతిలో ఇది ఇలా కనిపిస్తుంది:

డాకర్ డెమోన్ Docker_hostలో నడుస్తుంది మరియు కంటైనర్‌లను లాంచ్ చేస్తుంది. ఆదేశాలను పంపే క్లయింట్ ఉంది: చిత్రాన్ని నిర్మించండి, చిత్రాన్ని డౌన్‌లోడ్ చేయండి, కంటైనర్‌ను ప్రారంభించండి. డాకర్ డెమోన్ రిజిస్ట్రీకి వెళ్లి వాటిని అమలు చేస్తుంది. డాకర్ క్లయింట్ స్థానికంగా (యునిక్స్ సాకెట్‌కి) మరియు రిమోట్ హోస్ట్ నుండి TCP ద్వారా రెండింటినీ యాక్సెస్ చేయవచ్చు.

ప్రతి భాగం ద్వారా వెళ్దాం.

డాకర్ డెమోన్ - ఇది సర్వర్ భాగం, ఇది హోస్ట్ మెషీన్‌లో పనిచేస్తుంది: చిత్రాలను డౌన్‌లోడ్ చేస్తుంది మరియు వాటి నుండి కంటైనర్‌లను లాంచ్ చేస్తుంది, కంటైనర్‌ల మధ్య నెట్‌వర్క్‌ను సృష్టిస్తుంది, లాగ్‌లను సేకరిస్తుంది. “ఒక చిత్రాన్ని సృష్టించండి” అని మనం చెప్పినప్పుడు, దెయ్యం కూడా అదే చేస్తోంది.

డాకర్ CLI — డాకర్ క్లయింట్ భాగం, డెమోన్‌తో పనిచేయడానికి కన్సోల్ యుటిలిటీ. నేను పునరావృతం చేస్తున్నాను, ఇది స్థానికంగా మాత్రమే కాకుండా, నెట్వర్క్లో కూడా పని చేయవచ్చు.

ప్రాథమిక ఆదేశాలు:

docker ps - ప్రస్తుతం డాకర్ హోస్ట్‌లో నడుస్తున్న కంటైనర్‌లను చూపుతుంది.
డాకర్ చిత్రాలు - స్థానికంగా డౌన్‌లోడ్ చేయబడిన చిత్రాలను చూపించు.
డాకర్ శోధన <> - రిజిస్ట్రీలో ఒక చిత్రం కోసం శోధించండి.
డాకర్ లాగండి <> - రిజిస్ట్రీ నుండి మెషీన్‌కు చిత్రాన్ని డౌన్‌లోడ్ చేయండి.
డాకర్ బిల్డ్ < > - చిత్రాన్ని సేకరించండి.
డాకర్ రన్ <> - కంటైనర్‌ను ప్రారంభించండి.
డాకర్ rm <> - కంటైనర్‌ను తీసివేయండి.
డాకర్ లాగ్‌లు <> - కంటైనర్ లాగ్‌లు
డాకర్ స్టార్ట్/స్టాప్/రీస్టార్ట్ <> - కంటైనర్‌తో పని చేస్తుంది

మీరు ఈ ఆదేశాలను ప్రావీణ్యం పొంది, వాటిని ఉపయోగించడంలో నమ్మకంగా ఉంటే, మీరు వినియోగదారు స్థాయిలో డాకర్‌లో 70% నిష్ణాతులుగా పరిగణించండి.

Dockerfile - చిత్రాన్ని రూపొందించడానికి సూచనలు. దాదాపు ప్రతి సూచన కమాండ్ కొత్త పొర. ఒక ఉదాహరణ చూద్దాం.

డాకర్‌ఫైల్ ఇలా కనిపిస్తుంది: ఎడమ వైపున ఆదేశాలు, కుడి వైపున ఆర్గ్యుమెంట్‌లు. ఇక్కడ ఉన్న ప్రతి ఆదేశం (మరియు సాధారణంగా డాకర్‌ఫైల్‌లో వ్రాయబడింది) చిత్రంలో కొత్త పొరను సృష్టిస్తుంది.

ఎడమ వైపు చూస్తే, ఏమి జరుగుతుందో మీరు స్థూలంగా అర్థం చేసుకోవచ్చు. మేము ఇలా అంటాము: “మా కోసం ఫోల్డర్‌ను సృష్టించండి” - ఇది ఒక పొర. "ఫోల్డర్ పని చేయి" అనేది మరొక పొర, మరియు మొదలైనవి. లేయర్ కేక్ జీవితాన్ని సులభతరం చేస్తుంది. నేను మరొక డాకర్‌ఫైల్‌ని సృష్టించి, చివరి పంక్తిలో ఏదైనా మార్చినట్లయితే - నేను “పైథాన్” “main.py” కాకుండా వేరొకదాన్ని అమలు చేస్తే లేదా మరొక ఫైల్ నుండి డిపెండెన్సీలను ఇన్‌స్టాల్ చేస్తే - మునుపటి లేయర్‌లు కాష్‌గా మళ్లీ ఉపయోగించబడతాయి.

చిత్రం - ఇది కంటైనర్ ప్యాకేజింగ్; కంటైనర్లు చిత్రం నుండి ప్రారంభించబడ్డాయి. మేము ప్యాకేజీ మేనేజర్ యొక్క దృక్కోణం నుండి డాకర్‌ను చూస్తే (మేము deb లేదా rpm ప్యాకేజీలతో పని చేస్తున్నట్లుగా), అప్పుడు చిత్రం తప్పనిసరిగా rpm ప్యాకేజీ. yum ఇన్‌స్టాల్ ద్వారా మనం అప్లికేషన్‌ను ఇన్‌స్టాల్ చేయవచ్చు, దాన్ని తొలగించవచ్చు, రిపోజిటరీలో కనుగొనవచ్చు మరియు డౌన్‌లోడ్ చేసుకోవచ్చు. ఇది ఇక్కడ కూడా అదే విధంగా ఉంటుంది: చిత్రం నుండి కంటైనర్‌లు ప్రారంభించబడ్డాయి, అవి డాకర్ రిజిస్ట్రీలో నిల్వ చేయబడతాయి (yum లాగా, రిపోజిటరీలో), మరియు ప్రతి చిత్రానికి SHA-256 హాష్, పేరు మరియు ట్యాగ్ ఉంటుంది.

చిత్రం Dockerfile నుండి సూచనల ప్రకారం నిర్మించబడింది. Dockerfile నుండి ప్రతి సూచన కొత్త పొరను సృష్టిస్తుంది. పొరలను మళ్లీ ఉపయోగించుకోవచ్చు.

డాకర్ రిజిస్ట్రీ డాకర్ ఇమేజ్ రిపోజిటరీ. OS లాగానే, Docker ఒక పబ్లిక్ స్టాండర్డ్ రిజిస్ట్రీని కలిగి ఉంది - dockerhub. కానీ మీరు మీ స్వంత రిపోజిటరీని, మీ స్వంత డాకర్ రిజిస్ట్రీని నిర్మించుకోవచ్చు.

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

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

కోర్సు యొక్క లక్షణాలు మరియు పూర్తి ప్రోగ్రామ్‌ను మరింత వివరంగా అధ్యయనం చేయడానికి, దయచేసి లింక్‌ని అనుసరించండి: "డాకర్ వీడియో కోర్సు".

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

మూలం: www.habr.com