વીએમ અથવા ડોકર?

તમે કેવી રીતે જાણો છો કે તમને ડોકરની જરૂર છે અને VM નહીં? તમારે તે નક્કી કરવાની જરૂર છે કે તમે બરાબર શું અલગ કરવા માંગો છો. જો તમે બાંયધરીકૃત સમર્પિત સંસાધનો અને વર્ચ્યુઅલ હાર્ડવેર સાથે સિસ્ટમને અલગ કરવા માંગો છો, તો પસંદગી VM હોવી જોઈએ. જો તમારે ચાલી રહેલ એપ્લિકેશનોને અલગ સિસ્ટમ પ્રક્રિયાઓ તરીકે અલગ કરવાની જરૂર હોય, તો તમારે ડોકરની જરૂર પડશે.

તો ડોકર કન્ટેનર અને વીએમ વચ્ચે શું તફાવત છે?

વર્ચ્યુઅલ મશીન (VM) બધા વર્ચ્યુઅલ ઉપકરણો અને વર્ચ્યુઅલ હાર્ડ ડિસ્ક સાથેનું વર્ચ્યુઅલ કમ્પ્યુટર છે કે જેના પર વર્ચ્યુઅલ ડિવાઇસ ડ્રાઇવર્સ, મેમરી મેનેજમેન્ટ અને અન્ય ઘટકો સાથે નવું સ્વતંત્ર OS ઇન્સ્ટોલ કરેલું છે. એટલે કે, અમને ભૌતિક હાર્ડવેરનું એક એબ્સ્ટ્રેક્શન મળે છે જે અમને એક કમ્પ્યુટર પર ઘણા વર્ચ્યુઅલ કમ્પ્યુટર્સ ચલાવવાની મંજૂરી આપે છે.
ઇન્સ્ટોલ કરેલ VM તમારા કમ્પ્યુટરની ડિસ્ક પર અલગ અલગ રીતે જગ્યા લઈ શકે છે:

• નિશ્ચિત હાર્ડ ડિસ્ક જગ્યા, જે વર્ચ્યુઅલ હાર્ડ ડિસ્કને ઝડપી ઍક્સેસની મંજૂરી આપે છે અને ફાઈલ ફ્રેગમેન્ટેશનને ટાળે છે;
• ગતિશીલ મેમરી ફાળવણી. વધારાની એપ્લિકેશનો ઇન્સ્ટોલ કરતી વખતે, મેમરીને ગતિશીલ રીતે તેમના માટે ફાળવવામાં આવશે જ્યાં સુધી તે તેને ફાળવેલ મહત્તમ રકમ સુધી પહોંચે નહીં.

સર્વર દીઠ વધુ વર્ચ્યુઅલ મશીનો, તેઓ જેટલી વધુ જગ્યા લે છે, અને તમારી એપ્લિકેશન ચલાવવા માટે જરૂરી પર્યાવરણ માટે સતત સમર્થનની પણ જરૂર છે.

Docker કન્ટેનર-આધારિત એપ્લિકેશન બનાવવા માટેનું સોફ્ટવેર છે. કન્ટેનર અને વર્ચ્યુઅલ મશીનો સમાન ફાયદા ધરાવે છે, પરંતુ અલગ રીતે કાર્ય કરે છે. કન્ટેનર ઓછી જગ્યા લે છે કારણ કે... VM કરતાં યજમાન સિસ્ટમના વધુ વહેંચાયેલ સંસાધનોનો ફરીથી ઉપયોગ કરો, કારણ કે VM થી વિપરીત, તે OS સ્તર પર વર્ચ્યુઅલાઈઝેશન પૂરું પાડે છે, હાર્ડવેર સ્તર પર નહીં. આ અભિગમ ઓછી મેમરી ફૂટપ્રિન્ટ, ઝડપી જમાવટ અને સરળ સ્કેલિંગમાં પરિણમે છે.

કન્ટેનર હોસ્ટ સિસ્ટમને જરૂરી ઈન્ટરફેસ પૂરા પાડીને એપ્લીકેશનને સમાવિષ્ટ કરવા માટે વધુ કાર્યક્ષમ પદ્ધતિ પ્રદાન કરે છે. આ સુવિધા કન્ટેનરને સિસ્ટમના મુખ્ય ભાગને શેર કરવાની મંજૂરી આપે છે, જેમાં દરેક કન્ટેનર એક અલગ હોસ્ટ OS પ્રક્રિયા તરીકે ચાલે છે કે જે તેના પોતાના મેમરી વિસ્તારો (તેની પોતાની વર્ચ્યુઅલ એડ્રેસ સ્પેસ) ધરાવે છે. દરેક કન્ટેનરની વર્ચ્યુઅલ એડ્રેસ સ્પેસ તેની પોતાની હોવાથી, વિવિધ મેમરી એરિયાથી સંબંધિત ડેટા બદલી શકાતો નથી.
ડોકર માટે મૂળ ઓએસ એ Linux છે (ડોકરનો ઉપયોગ વિન્ડોઝ અને મેકઓએસ પર પણ થઈ શકે છે), તે તેના મુખ્ય ફાયદાઓનો ઉપયોગ કરે છે, જે તેને કર્નલ વિભાજનને ગોઠવવાની મંજૂરી આપે છે. વિન્ડોઝ પર ડોકર કન્ટેનર ચલાવવાનું Linux OS પર ચાલતા વર્ચ્યુઅલ મશીનની અંદર થશે, કારણ કે કન્ટેનર હોસ્ટ સિસ્ટમના OSને શેર કરે છે અને તેમના માટે મુખ્ય OS Linux છે.

કન્ટેનર - તે કેવી રીતે કાર્ય કરે છે?

કન્ટેનર એપ્લીકેશન-લેવલ એબ્સ્ટ્રેક્શન છે જે કોડ અને ડિપેન્ડન્સીને જોડે છે. કન્ટેનર હંમેશા છબીઓમાંથી બનાવવામાં આવે છે, લખી શકાય તેવું ટોચનું સ્તર ઉમેરીને અને વિવિધ પરિમાણોને પ્રારંભ કરીને. કારણ કે કન્ટેનરનું પોતાનું લખવાનું સ્તર હોય છે અને બધા ફેરફારો તે સ્તરમાં સંગ્રહિત થાય છે, બહુવિધ કન્ટેનર સમાન મુખ્ય છબીની ઍક્સેસ શેર કરી શકે છે.

દરેક કન્ટેનરને મુખ્ય સોલ્યુશન - docker-compose.yml માં સમાવિષ્ટ ડોકર-કંપોઝ પ્રોજેક્ટમાં ફાઇલ દ્વારા ગોઠવી શકાય છે. ત્યાં તમે કન્ટેનરનું નામ, બંદરો, ઓળખકર્તાઓ, સંસાધન મર્યાદાઓ, અન્ય કન્ટેનર વચ્ચે નિર્ભરતા જેવા વિવિધ પરિમાણો સેટ કરી શકો છો. જો તમે સેટિંગ્સમાં કન્ટેનર નામનો ઉલ્લેખ કરતા નથી, તો ડોકર દર વખતે એક નવું કન્ટેનર બનાવશે, તેને રેન્ડમલી નામ આપશે.

જ્યારે ઇમેજમાંથી કન્ટેનર શરૂ કરવામાં આવે છે, ત્યારે ડોકર નીચેના કોઈપણ સ્તરોની ટોચ પર વાંચવા-લખવા માટેની ફાઇલસિસ્ટમને માઉન્ટ કરે છે. આ તે છે જ્યાં અમે અમારા ડોકર કન્ટેનરને ચલાવવા માંગીએ છીએ તે બધી પ્રક્રિયાઓ ચાલશે.

જ્યારે ડોકર પ્રથમ કન્ટેનર શરૂ કરે છે, ત્યારે પ્રારંભિક વાંચન-લેખન સ્તર ખાલી હોય છે. જ્યારે ફેરફારો થાય છે, ત્યારે તેઓ આ સ્તર પર લાગુ થાય છે; ઉદાહરણ તરીકે, જો તમે કોઈ ફાઈલ બદલવા ઈચ્છો છો, તો તે ફાઈલ ફક્ત વાંચવા માટેના નીચેના સ્તરમાંથી રીડ-રાઈટ લેયર પર કોપી કરવામાં આવશે.
ફાઇલનું ફક્ત વાંચવા માટેનું સંસ્કરણ હજી પણ અસ્તિત્વમાં રહેશે, પરંતુ તે હવે નકલ હેઠળ છુપાયેલ છે. કન્ટેનરના જીવન ચક્રને ધ્યાનમાં લીધા વિના, ડેટા સ્ટોર કરવા માટે વોલ્યુમોનો ઉપયોગ કરવામાં આવે છે. જ્યારે કન્ટેનર બનાવવામાં આવે ત્યારે વોલ્યુમો શરૂ થાય છે.

ઇમેજ કન્ટેનર સાથે કેવી રીતે સંબંધિત છે?

છબી - દરેક કન્ટેનર માટેનું મુખ્ય તત્વ. ઇમેજ પ્રોજેક્ટમાં ઉમેરવામાં આવેલી ડોકરફાઇલમાંથી બનાવવામાં આવી છે અને તે ફાઇલ સિસ્ટમ્સ (સ્તરો)નો સમૂહ છે જે એકબીજાની ટોચ પર સ્તરવાળી છે અને એકસાથે જૂથબદ્ધ છે, ફક્ત વાંચવા માટે; સ્તરોની મહત્તમ સંખ્યા 127 છે.

દરેક ઈમેજના હાર્દમાં બેઝ ઈમેજ હોય ​​છે, જે FROM કમાન્ડ દ્વારા નિર્દિષ્ટ કરવામાં આવે છે - ડોકરફાઈલ ઈમેજ બનાવતી વખતે એન્ટ્રી પોઈન્ટ. દરેક સ્તર એ ફક્ત વાંચવા માટેનું સ્તર છે અને તે એક આદેશ દ્વારા રજૂ થાય છે જે ફાઇલ સિસ્ટમમાં ફેરફાર કરે છે, જે ડોકરફાઇલમાં લખાયેલ છે.
આ સ્તરોને એક ઇમેજમાં જોડવા માટે, ડોકર એડવાન્સ્ડ મલ્ટી લેયર્ડ યુનિયન ફાઇલ સિસ્ટમનો ઉપયોગ કરે છે (AuFS UnionFS ની ટોચ પર બનેલ છે), વિવિધ ફાઇલ સ્તરોમાંથી વિવિધ ફાઇલો અને ડિરેક્ટરીઓને પારદર્શક રીતે ઓવરલે કરવાની મંજૂરી આપે છે, એક સુસંગત ફાઇલ સિસ્ટમ બનાવે છે.

સ્તરોમાં મેટાડેટા હોય છે જે તમને રનટાઈમ અને બિલ્ડ ટાઈમ દરમિયાન દરેક લેયર વિશે સંબંધિત માહિતી સ્ટોર કરવાની મંજૂરી આપે છે. દરેક સ્તરમાં આગલા સ્તરની લિંક હોય છે; જો કોઈ સ્તરમાં કોઈ લિંક ન હોય, તો તે છબીનું ટોચનું સ્તર છે.

ડોકરફાઈલમાં આદેશો હોઈ શકે છે જેમ કે:

• FROM - છબી બનાવતી વખતે પ્રવેશ બિંદુ;
• જાળવણીકાર - છબીના માલિકનું નામ;
• RUN — ઇમેજ એસેમ્બલી દરમિયાન આદેશનો અમલ;
• ADD - હોસ્ટ ફાઈલને નવી ઈમેજમાં કોપી કરવી; જો તમે ફાઈલના URL નો ઉલ્લેખ કરો છો, તો Docker તેને ઉલ્લેખિત ડિરેક્ટરીમાં ડાઉનલોડ કરશે;
• ENV - પર્યાવરણ ચલો;
• સીએમડી - છબીના આધારે નવા કન્ટેનરની રચના શરૂ કરે છે;
• ENTRYPOINT - જ્યારે કન્ટેનર શરૂ થાય ત્યારે આદેશ ચલાવવામાં આવે છે.
• WORKDIR એ CMD આદેશ ચલાવવા માટે કાર્યકારી નિર્દેશિકા છે.
• USER - છબીના આધારે બનાવેલ કન્ટેનર માટે UID સેટ કરે છે.
• વોલ્યુમ - હોસ્ટ ડિરેક્ટરીને કન્ટેનરમાં માઉન્ટ કરે છે.
• EXPOSE એ કન્ટેનરમાં સાંભળેલા બંદરોનો સમૂહ છે.

યુનિયનએફએસ કેવી રીતે કામ કરે છે?

યુનિયનએફએસ - Linux અને FreeBSD માટે યુટિલિટી સ્ટેક ફાઇલ સિસ્ટમ (FS). આ FS કૉપિ-ઑન-રાઇટ મિકેનિઝમ (કૉપિ-ઑન-રાઇટ, COW) લાગુ કરે છે. UnionFS નું કાર્યકારી એકમ એક સ્તર છે; દરેક સ્તરને રુટમાંથી જ ડિરેક્ટરીઓના વંશવેલો સાથે એક અલગ સંપૂર્ણ સુવિધાયુક્ત ફાઇલ સિસ્ટમ તરીકે ગણવામાં આવવી જોઈએ. UnionFS અન્ય ફાઇલ સિસ્ટમ્સ માટે યુનિયન માઉન્ટ બનાવે છે અને વિવિધ ફાઇલ સિસ્ટમ્સ (જેને ફોર્ક્સ કહેવાય છે) માંથી ફાઇલો અને ડિરેક્ટરીઓને એક સુસંગત ફાઇલ સિસ્ટમમાં જોડવાની મંજૂરી આપે છે, પારદર્શક રીતે વપરાશકર્તાને.

સમાન પાથ સાથેની ડિરેક્ટરીઓના સમાવિષ્ટો પરિણામી ફાઇલ સિસ્ટમની એક એકીકૃત ડિરેક્ટરીમાં (એક જ નેમસ્પેસમાં) એકસાથે દેખાશે.

UnionFS નીચેના સિદ્ધાંતોના આધારે સ્તરોને જોડે છે:

• એક સ્તર ટોચના સ્તરનું સ્તર બને છે, બીજા અને અનુગામી સ્તરો નીચલા સ્તરના સ્તરો બને છે;
• લેયર ઑબ્જેક્ટ્સ વપરાશકર્તા માટે "ઉપરથી નીચે સુધી" ઉપલબ્ધ છે, એટલે કે. જો વિનંતી કરેલ ઑબ્જેક્ટ "ટોચ" સ્તરમાં હોય, તો "તળિયે" સ્તરમાં સમાન નામવાળા ઑબ્જેક્ટની હાજરીને ધ્યાનમાં લીધા વિના, તે પરત કરવામાં આવે છે; નહિંતર "નીચે" સ્તરનો ઑબ્જેક્ટ પાછો આવે છે; જો વિનંતી કરેલ ઑબ્જેક્ટ ન તો ત્યાં છે કે ન ત્યાં છે, તો ભૂલ "આવી કોઈ ફાઇલ અથવા ડિરેક્ટરી" પરત કરવામાં આવશે નહીં;
• કાર્યકારી સ્તર એ "ટોચ" એક છે, એટલે કે, ડેટા બદલવા માટેની બધી વપરાશકર્તા ક્રિયાઓ નીચલા સ્તરના સ્તરોની સામગ્રીને અસર કર્યા વિના, ફક્ત ટોચના સ્તરના સ્તર પર જ પ્રતિબિંબિત થાય છે.

એપ્લિકેશન ચલાવવા માટે કન્ટેનરનો ઉપયોગ કરવા માટે ડોકર એ સૌથી સામાન્ય તકનીક છે. તે લિનક્સ કર્નલ દ્વારા પૂરા પાડવામાં આવેલ cgroups અને નેમસ્પેસ પર નિર્માણ કરીને, ક્ષેત્રમાં પ્રમાણભૂત બની ગયું છે.

Docker અમને અલગ OS પ્રક્રિયાઓ તરીકે ચાલી રહેલા તમામ કન્ટેનર વચ્ચે OS ​​કર્નલને વિભાજિત કરીને એપ્લિકેશનને ઝડપથી જમાવવા અને ફાઇલ સિસ્ટમનો શ્રેષ્ઠ ઉપયોગ કરવાની મંજૂરી આપે છે.

સોર્સ: www.habr.com