ડોકર શું છે: ઇતિહાસ અને મૂળભૂત અમૂર્તમાં સંક્ષિપ્ત પ્રવાસ

સ્લર્મમાં 10મી ઓગસ્ટે શરૂ કરવામાં આવી હતી ડોકર વિડિઓ કોર્સ, જેમાં અમે તેનું સંપૂર્ણ વિશ્લેષણ કરીએ છીએ - મૂળભૂત એબ્સ્ટ્રેક્શન્સથી નેટવર્ક પરિમાણો સુધી.

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

ડોકર શું છે

ચાલો વિકિપીડિયા પરથી ડોકરની વ્યાખ્યા જોઈએ.

ડોકર એ કન્ટેનરાઇઝ્ડ વાતાવરણમાં એપ્લિકેશનના જમાવટ અને સંચાલનને સ્વચાલિત કરવા માટેનું સોફ્ટવેર છે.

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

મોનોલિથિક યુગ

મોનોલિથિક યુગ એ 2000 ના દાયકાની શરૂઆતનો છે, જ્યારે તમામ એપ્લિકેશનો એકવિધ હતા, જેમાં ઘણી બધી નિર્ભરતા હતી. વિકાસને ઘણો સમય લાગ્યો. તે જ સમયે, ત્યાં ઘણા બધા સર્વર્સ ન હતા; અમે બધા તેમને નામથી જાણતા હતા અને તેમનું નિરીક્ષણ કર્યું હતું. આવી રમુજી સરખામણી છે:

પાળતુ પ્રાણી ઘરેલું પ્રાણીઓ છે. મોનોલિથિક યુગમાં, અમે અમારા સર્વરોને પાલતુ પ્રાણીઓની જેમ માવજત, માવજત અને પ્રેમાળ, ધૂળના ડાઘને દૂર કરતા હતા. અને વધુ સારા સંસાધન વ્યવસ્થાપન માટે, અમે વર્ચ્યુઅલાઈઝેશનનો ઉપયોગ કર્યો: અમે એક સર્વર લીધું અને તેને અનેક વર્ચ્યુઅલ મશીનોમાં કાપી નાખ્યું, જેનાથી પર્યાવરણના અલગતાની ખાતરી થઈ.

હાયપરવાઈઝર-આધારિત વર્ચ્યુઅલાઈઝેશન સિસ્ટમ્સ

વર્ચ્યુઅલાઈઝેશન સિસ્ટમ્સ વિશે દરેક વ્યક્તિએ કદાચ સાંભળ્યું હશે: VMware, VirtualBox, Hyper-V, Qemu KVM, વગેરે. તેઓ એપ્લિકેશનને અલગતા અને સંસાધન વ્યવસ્થાપન પ્રદાન કરે છે, પરંતુ તેઓના ગેરફાયદા પણ છે. વર્ચ્યુઅલાઈઝેશન કરવા માટે, તમારે હાઈપરવાઈઝરની જરૂર છે. અને હાઇપરવાઇઝર એ એક સંસાધન ઓવરહેડ છે. અને વર્ચ્યુઅલ મશીન પોતે સામાન્ય રીતે સંપૂર્ણ કોલોસસ હોય છે - એક ભારે છબી જેમાં ઓપરેટિંગ સિસ્ટમ, Nginx, Apache અને કદાચ MySQL હોય છે. છબી મોટી છે અને વર્ચ્યુઅલ મશીન ચલાવવા માટે અસુવિધાજનક છે. પરિણામે, વર્ચ્યુઅલ મશીનો સાથે કામ ધીમું થઈ શકે છે. આ સમસ્યાને ઉકેલવા માટે, કર્નલ સ્તરે વર્ચ્યુઅલાઈઝેશન સિસ્ટમો બનાવવામાં આવી હતી.

કર્નલ-લેવલ વર્ચ્યુઅલાઈઝેશન સિસ્ટમ્સ

કર્નલ-લેવલ વર્ચ્યુઅલાઈઝેશન OpenVZ, Systemd-nspawn, LXC સિસ્ટમો દ્વારા આધારભૂત છે. આવા વર્ચ્યુઅલાઈઝેશનનું આકર્ષક ઉદાહરણ LXC (લિનક્સ કન્ટેનર) છે.

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

આવશ્યકપણે LXC કન્ટેનર બનાવે છે. વર્ચ્યુઅલ મશીનો અને કન્ટેનર વચ્ચે શું તફાવત છે?

કન્ટેનર પ્રક્રિયાઓને અલગ કરવા માટે યોગ્ય નથી: કર્નલ સ્તરે વર્ચ્યુઅલાઈઝેશન સિસ્ટમ્સમાં નબળાઈઓ જોવા મળે છે જે તેમને કન્ટેનરથી યજમાન સુધી છટકી જવાની મંજૂરી આપે છે. તેથી, જો તમારે કંઈક અલગ કરવાની જરૂર હોય, તો વર્ચ્યુઅલ મશીનનો ઉપયોગ કરવો વધુ સારું છે.

વર્ચ્યુઅલાઈઝેશન અને કન્ટેનરાઈઝેશન વચ્ચેના તફાવતો આકૃતિમાં જોઈ શકાય છે.
હાર્ડવેર હાઇપરવાઇઝર, OS ની ટોચ પર હાઇપરવાઇઝર અને કન્ટેનર છે.

જો તમે ખરેખર કંઈક અલગ કરવા માંગતા હોવ તો હાર્ડવેર હાઈપરવાઈઝર સરસ છે. કારણ કે મેમરી પૃષ્ઠો અને પ્રોસેસરોના સ્તરે અલગ કરવું શક્ય છે.

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

કર્નલ સ્તરે કન્ટેનરાઇઝેશન માટે શું વપરાય છે

મુખ્ય તકનીકો જે તમને અન્ય પ્રક્રિયાઓથી અલગ કન્ટેનર બનાવવાની મંજૂરી આપે છે તે છે નેમસ્પેસ અને નિયંત્રણ જૂથો.

નેમસ્પેસ: PID, નેટવર્કિંગ, માઉન્ટ અને વપરાશકર્તા. ત્યાં વધુ છે, પરંતુ સમજવાની સરળતા માટે અમે આ પર ધ્યાન કેન્દ્રિત કરીશું.

PID નેમસ્પેસ પ્રક્રિયાઓને મર્યાદિત કરે છે. જ્યારે, ઉદાહરણ તરીકે, આપણે PID નેમસ્પેસ બનાવીએ છીએ અને ત્યાં એક પ્રક્રિયા મૂકીએ છીએ, તે PID 1 સાથે બને છે. સામાન્ય રીતે સિસ્ટમ્સમાં PID 1 એ systemd અથવા init હોય છે. તદનુસાર, જ્યારે આપણે નવી નેમસ્પેસમાં પ્રક્રિયા મૂકીએ છીએ, ત્યારે તે PID 1 પણ મેળવે છે.

નેટવર્કિંગ નેમસ્પેસ તમને નેટવર્કને મર્યાદિત/અલગ કરવા અને તમારા પોતાના ઇન્ટરફેસને અંદર મૂકવાની પરવાનગી આપે છે. માઉન્ટ એ ફાઇલ સિસ્ટમ મર્યાદા છે. વપરાશકર્તા - વપરાશકર્તાઓ પર પ્રતિબંધ.

નિયંત્રણ જૂથો: મેમરી, CPU, IOPS, નેટવર્ક - કુલ લગભગ 12 સેટિંગ્સ. અન્યથા તેઓને Cgroups (“C-જૂથો”) પણ કહેવામાં આવે છે.

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

કન્ટેનરાઇઝેશન સંપૂર્ણ રીતે કાર્ય કરવા માટે, વધારાની તકનીકોનો ઉપયોગ કરવામાં આવે છે: ક્ષમતાઓ, કૉપિ-ઑન-રાઇટ અને અન્ય.

ક્ષમતાઓ એ છે જ્યારે આપણે કોઈ પ્રક્રિયાને કહીએ છીએ કે તે શું કરી શકે છે અને શું કરી શકતી નથી. કર્નલ સ્તરે, આ ઘણા પરિમાણો સાથે ફક્ત બીટમેપ્સ છે. ઉદાહરણ તરીકે, રૂટ વપરાશકર્તા પાસે સંપૂર્ણ વિશેષાધિકારો છે અને તે બધું કરી શકે છે. ટાઇમ સર્વર સિસ્ટમનો સમય બદલી શકે છે: તે ટાઇમ કૅપ્સ્યુલ પર ક્ષમતાઓ ધરાવે છે, અને બસ. વિશેષાધિકારોની મદદથી, તમે પ્રક્રિયાઓ માટેના પ્રતિબંધોને લવચીક રીતે ગોઠવી શકો છો અને તે રીતે તમારી જાતને સુરક્ષિત કરી શકો છો.

કોપી-ઓન-રાઈટ સિસ્ટમ અમને ડોકર ઈમેજીસ સાથે કામ કરવા અને તેનો વધુ કાર્યક્ષમ ઉપયોગ કરવાની મંજૂરી આપે છે.

ડોકરને હાલમાં Cgroups v2 સાથે સુસંગતતા સમસ્યાઓ છે, તેથી આ લેખ ખાસ કરીને Cgroups v1 પર ધ્યાન કેન્દ્રિત કરે છે.

પરંતુ ચાલો ઇતિહાસ પર પાછા જઈએ.

જ્યારે વર્ચ્યુઅલાઈઝેશન સિસ્ટમો કર્નલ સ્તરે દેખાઈ, ત્યારે તેઓ સક્રિય રીતે ઉપયોગમાં લેવાનું શરૂ કર્યું. હાઇપરવાઇઝર પરનો ઓવરહેડ અદૃશ્ય થઈ ગયો, પરંતુ કેટલીક સમસ્યાઓ રહી:

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

આ બધી સમસ્યાઓના નિરાકરણ માટે, આગામી યુગ આવી ગયો છે.

કન્ટેનર યુગ

જ્યારે કન્ટેનરનો યુગ આવ્યો, ત્યારે તેમની સાથે કામ કરવાની ફિલસૂફી બદલાઈ ગઈ:

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

યાદ રાખો કે મેં પાલતુ વિ પશુઓ વિશે શું કહ્યું હતું? પહેલાં, દાખલાઓ ઘરેલું પ્રાણીઓ જેવા હતા, પરંતુ હવે તે ઢોર જેવા થઈ ગયા છે. પહેલાં, એક મોનોલિથ - એક એપ્લિકેશન હતી. હવે તે 100 માઇક્રોસર્વિસિસ, 100 કન્ટેનર છે. કેટલાક કન્ટેનરમાં 2-3 પ્રતિકૃતિઓ હોઈ શકે છે. દરેક કન્ટેનરને નિયંત્રિત કરવું આપણા માટે ઓછું મહત્વનું બની જાય છે. અમારા માટે જે વધુ મહત્વનું છે તે સેવાની ઉપલબ્ધતા છે: કન્ટેનરનો આ સમૂહ શું કરે છે. આ મોનીટરીંગ માટેના અભિગમોને બદલે છે.

2014-2015 માં, ડોકરનો વિકાસ થયો - તે તકનીક કે જેના વિશે આપણે હવે વાત કરીશું.

ડોકરે ફિલસૂફી અને પ્રમાણિત એપ્લિકેશન પેકેજિંગમાં ફેરફાર કર્યો. ડોકરનો ઉપયોગ કરીને, અમે એપ્લિકેશનને પેકેજ કરી શકીએ છીએ, તેને રિપોઝીટરીમાં મોકલી શકીએ છીએ, તેને ત્યાંથી ડાઉનલોડ કરી શકીએ છીએ અને તેને જમાવી શકીએ છીએ.

અમે ડોકર કન્ટેનરમાં અમને જોઈતી દરેક વસ્તુ મૂકીએ છીએ, તેથી નિર્ભરતાની સમસ્યા હલ થાય છે. ડોકર પ્રજનનક્ષમતાની ખાતરી આપે છે. મને લાગે છે કે ઘણા લોકોને પુનઃઉત્પાદનક્ષમતાનો સામનો કરવો પડ્યો છે: બધું તમારા માટે કામ કરે છે, તમે તેને ઉત્પાદન તરફ ધકેલી દો છો, અને ત્યાં તે કામ કરવાનું બંધ કરે છે. ડોકર સાથે આ સમસ્યા દૂર થઈ જાય છે. જો તમારું ડોકર કન્ટેનર શરૂ થાય છે અને તેને જે કરવાની જરૂર છે તે કરે છે, તો ઉચ્ચ સંભાવના સાથે તે ઉત્પાદનમાં શરૂ થશે અને ત્યાં પણ તે જ કરશે.

ઓવરહેડ વિશે વિષયાંતર

ઓવરહેડ્સ વિશે હંમેશા વિવાદો છે. કેટલાક લોકો માને છે કે ડોકર વધારાનો ભાર વહન કરતું નથી, કારણ કે તે લિનક્સ કર્નલ અને કન્ટેનરાઇઝેશન માટે જરૂરી તેની બધી પ્રક્રિયાઓનો ઉપયોગ કરે છે. જેમ કે, "જો તમે કહો છો કે ડોકર ઓવરહેડ છે, તો Linux કર્નલ ઓવરહેડ છે."

બીજી બાજુ, જો તમે વધુ ઊંડાણમાં જાઓ, તો ખરેખર ડોકરમાં ઘણી બધી વસ્તુઓ છે જે, ખેંચાણ સાથે, ઓવરહેડ કહી શકાય.

પ્રથમ PID નેમસ્પેસ છે. જ્યારે આપણે નેમસ્પેસમાં કોઈ પ્રક્રિયા મૂકીએ છીએ, ત્યારે તેને PID 1 સોંપવામાં આવે છે. તે જ સમયે, આ પ્રક્રિયામાં બીજી PID હોય છે, જે કન્ટેનરની બહાર હોસ્ટ નેમસ્પેસ પર સ્થિત હોય છે. ઉદાહરણ તરીકે, અમે Nginx ને કન્ટેનરમાં લોન્ચ કર્યું, તે PID 1 (માસ્ટર પ્રક્રિયા) બની ગયું. અને હોસ્ટ પર તેની પાસે PID 12623 છે. અને તે કેટલું ઓવરહેડ છે તે કહેવું મુશ્કેલ છે.

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

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

ડોકર ખ્યાલ વિશે

ડોકરમાં ઘણા ઘટકોનો સમાવેશ થાય છે:

1. ડોકર ડિમન એ જ કન્ટેનર એન્જિન છે; કન્ટેનર લોંચ કરે છે.
2. ડોકર સીઆઈઆઈ એ ડોકર મેનેજમેન્ટ યુટિલિટી છે.
3. ડોકરફાઇલ - ઇમેજ કેવી રીતે બનાવવી તેની સૂચનાઓ.
4. ઈમેજ - ઈમેજ જેમાંથી કન્ટેનર રોલઆઉટ કરવામાં આવે છે.
5. કન્ટેનર.
6. ડોકર રજિસ્ટ્રી એ ઇમેજ રિપોઝીટરી છે.

યોજનાકીય રીતે તે કંઈક આના જેવું લાગે છે:

ડોકર ડિમન Docker_host પર ચાલે છે અને કન્ટેનર લોન્ચ કરે છે. ત્યાં એક ક્લાયંટ છે જે આદેશો મોકલે છે: છબી બનાવો, છબી ડાઉનલોડ કરો, કન્ટેનર લોંચ કરો. ડોકર ડિમન રજિસ્ટ્રીમાં જાય છે અને તેમને એક્ઝિક્યુટ કરે છે. ડોકર ક્લાયંટ સ્થાનિક રીતે (યુનિક્સ સોકેટમાં) અને દૂરસ્થ હોસ્ટમાંથી TCP દ્વારા બંનેને ઍક્સેસ કરી શકે છે.

ચાલો દરેક ઘટકમાંથી પસાર થઈએ.

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

ડોકર CLI — ડોકર ક્લાયન્ટ ભાગ, ડિમન સાથે કામ કરવા માટે કન્સોલ ઉપયોગિતા. હું પુનરાવર્તન કરું છું, તે ફક્ત સ્થાનિક રીતે જ નહીં, પણ નેટવર્ક પર પણ કામ કરી શકે છે.

મૂળભૂત આદેશો:

ડોકર પીએસ - કન્ટેનર બતાવો જે હાલમાં ડોકર હોસ્ટ પર ચાલી રહ્યા છે.
ડોકર છબીઓ - સ્થાનિક રીતે ડાઉનલોડ કરેલી છબીઓ બતાવો.
ડોકર શોધ <> - રજિસ્ટ્રીમાં છબી માટે શોધો.
ડોકર પુલ <> - રજિસ્ટ્રીમાંથી મશીન પર એક છબી ડાઉનલોડ કરો.
ડોકર બિલ્ડ < > - છબી એકત્રિત કરો.
ડોકર રન <> - કન્ટેનર લોંચ કરો.
docker rm <> - કન્ટેનર દૂર કરો.
ડોકર લોગ્સ <> - કન્ટેનર લોગ્સ
docker start/stop/restart <> - કન્ટેનર સાથે કામ કરવું

જો તમે આ આદેશોમાં નિપુણતા ધરાવો છો અને તેનો ઉપયોગ કરવામાં વિશ્વાસ ધરાવો છો, તો તમારી જાતને વપરાશકર્તા સ્તરે ડોકરમાં 70% નિપુણ ગણો.

ડોકરફાઇલ - છબી બનાવવા માટેની સૂચનાઓ. લગભગ દરેક સૂચના આદેશ એક નવું સ્તર છે. ચાલો એક ઉદાહરણ જોઈએ.

ડોકરફાઇલ આના જેવું દેખાય છે: ડાબી બાજુના આદેશો, જમણી તરફ દલીલો. દરેક આદેશ જે અહીં છે (અને સામાન્ય રીતે ડોકરફાઈલમાં લખાયેલ છે) ઈમેજમાં એક નવું લેયર બનાવે છે.

ડાબી બાજુ જોઈને પણ, તમે લગભગ સમજી શકો છો કે શું થઈ રહ્યું છે. અમે કહીએ છીએ: "અમારા માટે એક ફોલ્ડર બનાવો" - આ એક સ્તર છે. "ફોલ્ડરને કાર્યશીલ બનાવો" એ બીજું સ્તર છે, વગેરે. લેયર કેક જીવનને સરળ બનાવે છે. જો હું બીજી ડોકરફાઈલ બનાવીશ અને છેલ્લી લીટીમાં કંઈક બદલું છું - તો હું “python” “main.py” સિવાય બીજું કંઈક ચલાવું છું, અથવા બીજી ફાઇલમાંથી ડિપેન્ડન્સી ઇન્સ્ટોલ કરું છું- તો પાછલા સ્તરોનો કેશ તરીકે ફરીથી ઉપયોગ કરવામાં આવશે.

છબી - આ કન્ટેનર પેકેજિંગ છે; કન્ટેનર ઇમેજમાંથી લોંચ કરવામાં આવે છે. જો આપણે ડોકરને પેકેજ મેનેજરના દૃષ્ટિકોણથી જોઈએ (જેમ કે આપણે ડેબ અથવા આરપીએમ પેકેજો સાથે કામ કરી રહ્યા છીએ), તો ઇમેજ આવશ્યકપણે આરપીએમ પેકેજ છે. yum install દ્વારા અમે એપ્લિકેશન ઇન્સ્ટોલ કરી શકીએ છીએ, તેને કાઢી શકીએ છીએ, તેને રીપોઝીટરીમાં શોધી શકીએ છીએ અને તેને ડાઉનલોડ કરી શકીએ છીએ. તે અહીં લગભગ સમાન છે: કન્ટેનર ઇમેજમાંથી લોંચ કરવામાં આવે છે, તે ડોકર રજિસ્ટ્રીમાં સંગ્રહિત થાય છે (યમ જેવું જ, રિપોઝીટરીમાં), અને દરેક ઇમેજમાં SHA-256 હેશ, નામ અને ટેગ હોય છે.

છબી ડોકરફાઇલની સૂચનાઓ અનુસાર બનાવવામાં આવી છે. Dockerfile માંથી દરેક સૂચના એક નવું સ્તર બનાવે છે. સ્તરોનો ફરીથી ઉપયોગ કરી શકાય છે.

ડોકર રજિસ્ટ્રી ડોકર ઇમેજ રિપોઝીટરી છે. OS ની જેમ જ, Docker પાસે જાહેર માનક રજિસ્ટ્રી છે - dockerhub. પરંતુ તમે તમારી પોતાની રીપોઝીટરી, તમારી પોતાની ડોકર રજીસ્ટ્રી બનાવી શકો છો.

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

"એક કન્ટેનર, એક પ્રક્રિયા" જરૂરિયાત PID નેમસ્પેસ સાથે સંબંધિત છે. જ્યારે નેમસ્પેસમાં PID 1 સાથેની પ્રક્રિયા શરૂ થાય છે, જો તે અચાનક મૃત્યુ પામે છે, તો આખું કન્ટેનર પણ મૃત્યુ પામે છે. જો ત્યાં બે પ્રક્રિયાઓ ચાલી રહી છે: એક જીવંત છે અને બીજી મૃત છે, તો કન્ટેનર હજી પણ જીવંત રહેશે. પરંતુ આ શ્રેષ્ઠ વ્યવહારનો પ્રશ્ન છે, અમે તેના વિશે અન્ય સામગ્રીઓમાં વાત કરીશું.

કોર્સની વિશેષતાઓ અને સંપૂર્ણ પ્રોગ્રામનો વધુ વિગતવાર અભ્યાસ કરવા માટે, કૃપા કરીને લિંકને અનુસરો: “ડોકર વિડિઓ કોર્સ».

લેખક: માર્સેલ ઇબ્રાએવ, પ્રમાણિત કુબરનેટ્સ એડમિનિસ્ટ્રેટર, સાઉથબ્રિજ ખાતે પ્રેક્ટિસ એન્જિનિયર, સ્લર્મ કોર્સના સ્પીકર અને ડેવલપર.

સોર્સ: www.habr.com