એક સિંગલ કન્ટેનર ડિપ્લોય કરવું સરળ છે. દસ ડિપ્લોય કરવા મેનેજ કરી શકાય તેવા છે. પરંતુ એકવાર તમે ડઝનબંધ મશીનો પર સેંકડો કન્ટેનર ચલાવવા માંડો, પછી મેન્યુઅલ મેનેજમેન્ટ મુશ્કેલ રહેવાને બદલે અશક્ય બની જાય છે. કયું કન્ટેનર ક્યાં છે તેનો તમે ટ્રેક ગુમાવી દો છો. એક સર્વર બંધ થઈ જાય છે, અને જ્યાં સુધી કોઈ તેને ફરીથી શરૂ કરવા માટે જાગી ન જાય ત્યાં સુધી તમારી એપ્લિકેશન ગાયબ થઈ જાય છે. તમે નવા ઇન્સ્ટન્સ શરૂ કરી શકો તે પહેલાં જ ટ્રાફિકમાં થતો વધારો તમારા સેટઅપને ઓવરવેમ કરી દે છે. બરાબર અહીં જ Kubernetes ની ભૂમિકા શરૂ થાય છે. તે માત્ર બીજું કોઈ DevOps ટૂલ નથી. તે એક ઓર્કેસ્ટ્રેશન લેયર છે જે કન્ટેનર મેનેજમેન્ટને સ્ક્રિપ્ટિંગ એક્સરસાઇઝને બદલે કંટ્રોલ પ્રોબ્લેમ તરીકે જુએ છે.
સ્ક્રિપ્ટ્સ અંતે કેમ નિષ્ફળ જાય છે
મોટાભાગની ટીમો શેલ સ્ક્રિપ્ટ્સ અથવા બેઝિક ઓટોમેશનથી શરૂઆત કરે છે. તેઓ ઇમેજ પુલ કરવા, કન્ટેનર શરૂ કરવા, લોગ્સ જોવા અને નિષ્ફળ પ્રક્રિયાઓને ફરીથી શરૂ કરવા માટે કમાન્ડ લખે છે. આ અભિગમ 'પ્રૂફ ઓફ કોન્સેપ્ટ' માટે કામ કરે છે, પરંતુ વાસ્તવિક દુનિયાના લોડ હેઠળ તે નિષ્ફળ જાય છે. માઇક્રોસર્વિસીસ અલગ-અલગ હોસ્ટ પર એકબીજા સાથે વાત કરે છે, ચોક્કસ એન્વાયરમેન્ટ વેરિયેબલ્સ પર આધાર રાખે છે, કન્ટેનર રીસ્ટાર્ટ થયા પછી પણ ટકી રહે તેવા પર્સિસ્ટન્ટ સ્ટોરેજની જરૂર હોય છે, અને વર્ઝન વચ્ચે સુસંગત નેટવર્કિંગની અપેક્ષા રાખે છે. જ્યારે વર્ચ્યુઅલ મશીન ગાયબ થઈ જાય ત્યારે સ્ક્રિપ્ટ વર્કલોડને આપમેળે રિશેડ્યુલ કરી શકતી નથી. તે ક્રેશ લૂપમાં ફસાયેલા ઇન્સ્ટન્સને અવગણીને હેલ્ધી ઇન્સ્ટન્સ વચ્ચે નેટવર્ક ટ્રાફિકને વિતરિત કરી શકતી નથી. Kubernetes આ સમસ્યાનો ઉકેલ ક્લસ્ટરને જ તે નિર્ણયો માટે જવાબદાર બનાવીને લાવે છે. તમે શું ઈચ્છો છો તેનું વર્ણન કરો, અને સિસ્ટમ સતત તે સ્ટેટ જાળવી રાખે છે.
તે તમને આપેલી ત્રણ મુખ્ય બાબતો
Kubernetes ત્રણ મુખ્ય ક્ષમતાઓ પ્રદાન કરે છે જે મેન્યુઅલ ફાયરફાઈટિંગને ઓટોમેટેડ વિશ્વસનીયતા સાથે બદલી નાખે છે.
High availability એટલે કે જ્યારે તમારા ઇન્ફ્રાસ્ટ્રક્ચરના અમુક ભાગો નિષ્ફળ જાય ત્યારે પણ તમારી એપ્લિકેશન્સ ઓનલાઇન રહે છે. જો કોઈ કન્ટેનર ક્રેશ થાય છે, તો Kubernetes તેને સેકન્ડોમાં રિપ્લેસ કરે છે. જો આખું વર્કર નોડ બંધ થઈ જાય, તો શેડ્યુલર મિસિંગ હાર્ટબીટને નોટિસ કરે છે અને અસરગ્રસ્ત વર્કલોડ્સને ક્લસ્ટરમાં અન્ય હેલ્ધી મશીનો પર ખસેડે છે. સિસ્ટમ તમે વ્યાખ્યાયિત કરેલા ઇચ્છિત સ્ટેટ પર સતત નજર રાખે છે અને માનવીય હસ્તક્ષેપ વગર તેમાં આવતા ફેરફારોને સુધારે છે.
Scalability એટલે કે તમારી એપ્લિકેશન્સ તમારા યુઝર્સની સાથે વધે છે. માત્ર બે કલાકના ટ્રાફિક પીકને સહન કરવા માટે વીસ સર્વર્સ તૈયાર રાખવાને બદલે, તમે CPU વપરાશ અથવા રિક્વેસ્ટ લેટન્સી જેવા મહત્વના મેટ્રિક્સ વ્યાખ્યાયિત કરો છો, અને જ્યારે થ્રેશોલ્ડ ઓળંગાય ત્યારે ક્લસ્ટરને વધુ કન્ટેનર ઇન્સ્ટન્સ ઉમેરવા દો છો. જ્યારે માંગ ઘટે છે, ત્યારે રેપ્લિકા કાઉન્ટ ફરીથી ઘટે છે. તમે જેની જરૂર હોય છે, જ્યારે જરૂર હોય ત્યારે તેના માટે જ ચૂકવણી કરો છો.
Disaster recovery એટલે કે ક્રેશ થયા પછી તમારો ડેટા અને કોન્ફિગરેશન પાછું મળે છે. Kubernetes આખા ક્લસ્ટર સ્ટેટને ડિસ્ટ્રિબ્યુટેડ કી-વેલ્યુ સ્ટોરમાં સ્ટોર કરે છે. જો કોઈ મોટી નિષ્ફળતા વર્કર નોડ્સ અથવા કંટ્રોલ પ્લેનના અમુક ભાગને પણ ભૂંસી નાખે, તો તે સ્ટોર કરેલું સ્ટેટ સિસ્ટમને તમારા વર્કલોડ્સને બરાબર તે જ રીતે ફરીથી બનાવવા દે છે જે રીતે તે કોન્ફિગર કરવામાં આવ્યા હતા. તમારો ડેટા પાછો આવે છે કારણ કે ઓર્કેસ્ટ્રેટરને યાદ હોય છે કે તે કેવું હોવું જોઈએ.
સેટઅપ: મગજ અને સ્નાયુ (Brains and Muscle)
Kubernetes ક્લસ્ટરમાં બે મૂળભૂત ભૂમિકાઓ હોય છે જેને ડ્રાફ્ટમાં મગજ અને સ્નાયુ તરીકે વર્ણવવામાં આવ્યા છે, અને આ ઉદાહરણ વ્યવહારમાં પણ સાચું ઠરે છે.
Master Node એ મગજ છે. તે તમારી કસ્ટમર-ફેસિંગ એપ્લિકેશન્સ ચલાવતું નથી. તેના બદલે, તે કંટ્રોલ પ્લેન ઘટકોને હોસ્ટ કરે છે જે કાર્યો શેડ્યુલ કરે છે, ક્લસ્ટર સ્ટેટ મેનેજ કરે છે અને ફેરફારો સામે પ્રતિસાદ આપે છે. જ્યારે તમે કોઈ કમાન્ડ આપો છો અથવા કોન્ફિગરેશન ફાઇલ સબમિટ કરો છો, ત્યારે માસ્ટર નોડ નક્કી કરે છે કે વર્કલોડ ક્યાં હોવું જોઈએ, તે હેલ્ધી છે કે નહીં, અને જો તે ન હોય તો શું કરવું.
Worker Nodes એ સ્નાયુ છે. દરેક વર્કર એક લાઇટવેઇટ એજન્ટ ચલાવે છે જે માસ્ટર સાથે વાતચીત કરે છે અને વાસ્તવિક પોડ્સ (pods) ચલાવવા માટે કન્ટેનર રનટાઇમનો ઉપયોગ કરે છે. આ નોડ્સ એ છે જ્યાં તમારો એપ્લિકેશન કોડ CPU અને મેમરીનો ઉપયોગ કરે છે. વધુ વર્કર નોડ્સ ઉમેરો, અને તમારા ક્લસ્ટરની ક્ષમતા વધશે. રિડન્ડન્સી માટે કોન્ફિગર કરેલા વધુ માસ્ટર નોડ્સ ઉમેરો, અને તમારું કંટ્રોલ પ્લેન વ્યક્તિગત હાર્ડવેર નિષ્ફળતાઓ સામે સક્ષમ બનશે.
Pods, Containers, અને Services
Kubernetes સાથે કામ કરવા માટે, તમારે ત્રણ શબ્દો સમજવાની જરૂર છે જે સોફ્ટવેર કેવી રીતે પેકેજ કરવામાં આવે છે અને તેના સુધી કેવી રીતે પહોંચવું તે વ્યાખ્યાયિત કરે છે.
Containers એ એવા પેકેજ છે જે તમારી એપ્લિકેશનને તેની ડિપેન્ડન્સીઝ, લાઇબ્રેરીઝ અને કોન્ફિગરેશન સાથે બંડલ કરે છે. તેઓ સોફ્ટવેરને અન્ડરલાઇંગ હોસ્ટથી અલગ કરે છે જેથી તે ડેવલપમેન્ટ, સ્ટેજિંગ અને પ્રોડક્શનમાં એકસરખી રીતે ચાલે.
Pods એ Kubernetes માં સૌથી નાની ડિપ્લોય કરી શકાય તેવી યુનિટ છે. એક Pod એક અથવા વધુ કન્ટેનર્સને આવરી લે છે જેને સંસાધનો (resources) શેર કરવાની જરૂર હોય છે. તેઓ એક જ નેટવર્ક નેમસ્પેસ શેર કરે છે અને સમાન લોકલ સ્ટોરેજ વોલ્યુમ્સનો ઉપયોગ કરી શકે છે. આ મહત્વનું છે: તમે સીધું જ કોઈ કન્ટેનર ડિપ્લોય નથી કરતા. તમે તેને સમાવતું એક Pod ડિપ્લોય કરો છો. Pods જાણીજોઈને ક્ષણભંગુર (ephemeral) રાખવામાં આવે છે. પરિસ્થિતિ બદલાતા તેઓ બનાવવામાં આવે છે, નાશ કરવામાં આવે છે અને બદલવામાં આવે છે. તેમનું આયુષ્ય ડિઝાઈન મુજબ જ ડાયનેમિક હોય છે.
Services એટલા માટે અસ્તિત્વમાં છે કારણ કે Pods અસ્થાયી (transient) હોય છે. જ્યારે પણ Pod રિસ્ટાર્ટ થાય છે, ત્યારે તેને સંભવિતપણે નવો ઇન્ટરનલ IP એડ્રેસ મળે છે. જો તમારા એપ્લિકેશનના અન્ય ભાગો સીધા આ બદલાતા એડ્રેસ સાથે કનેક્ટ થવાનો પ્રયાસ કરે, તો તે સતત નિષ્ફળ જાય. એક Service તમારા Pods ને ફિક્સ્ડ IP એડ્રેસ અને DNS નામ આપે છે. તે એક સ્થિર 'ફ્રન્ટ ડોર' તરીકે કામ કરે છે, જે તેના સિલેક્ટર સાથે મેચ થતા તમામ હેલ્ધી Pods વચ્ચે આવતા રિક્વેસ્ટ્સનું લોડ-બેલેન્સિંગ કરે છે. આ તમારા ક્લાયન્ટ્સને વ્યક્તિગત કન્ટેનર લાઈફ સાયકલના અરાજકતાથી અલગ કરે છે.
સ્કેલ પર Kubernetes: Netflix નું ઉદાહરણ
Netflix તેના કન્ટેન્ટ ડિલિવરી નેટવર્કને મેનેજ કરવા માટે Kubernetes નો ઉપયોગ કરે છે. આ ઇન્ફ્રાસ્ટ્રક્ચર વિશ્વભરના લાખો દર્શકોને એકસાથે વિડિયો સ્ટ્રીમ્સ પહોંચાડે છે. જ્યારે કોઈ લોકપ્રિય શો આવે છે અને માંગ વધે છે, ત્યારે ક્લસ્ટર એવા કેશ નોડ્સ (cache nodes) ને સ્કેલ આઉટ કરે છે જે વિડિયો સેગમેન્ટ્સને યુઝર્સની નજીક સ્ટોર કરે છે. જો કોઈ પ્રાદેશિક નોડ નિષ્ફળ જાય, તો ટ્રાફિક આપમેળે ફરીથી રૂટ થાય છે. પરિણામ એ છે કે એન્જિનિયરને મેન્યુઅલ ઇમરજન્સી પેજ કર્યા વગર લાખો લોકો માટે મૂવીઝ ચાલતી રહે છે. ઓર્કેસ્ટ્રેટર સ્કેલ અને નિષ્ફળતાને સંભાળે છે જેથી સર્વિસ અવિરત ચાલુ રહે.
શરૂઆત: YAML, JSON, અને API Server
Kubernetes સાથે શરૂઆત કરવાનો અર્થ છે ઇમ્પરેટિવ 'ક્લિક-ઓપ્સ' (click-ops) છોડીને ડિક્લેરેટિવ કન્ફિગરેશન અપનાવવું. તમે YAML અથવા JSON ફાઇલોમાં તમને જે જોઈએ છે તે લખો છો. આ મેનિફેસ્ટ્સ કન્ટેનર ઇમેજથી લઈને રેપ્લિકાની સંખ્યા, એક્સપોઝ્ડ પોર્ટ્સ, એન્વાયરમેન્ટ વેરિયેબલ્સ અને સ્ટોરેજ માઉન્ટ્સ સુધી બધું જ વર્ણવે છે. એકવાર તમારી ફાઇલ તૈયાર થઈ જાય પછી, તમે તેને માસ્ટર નોડ પરના API server પર મોકલો છો. કંટ્રોલ પ્લેન તે ડિક્લેરેશન સ્વીકારે છે, તેને ક્લસ્ટર સ્ટેટ ડેટાબેઝમાં સ્ટોર કરે છે, અને પછી વાસ્તવિકતાને તમારા વર્ણન મુજબ બનાવવા માટે કામ શરૂ કરે છે. તમે Kubernetes ને તેનું કામ બરાબર કેવી રીતે કરવું તે નથી કહેતા. તમે તેને જણાવો છો કે અંતિમ પરિણામ શું હોવું જોઈએ, અને તે તેના સ્ટેપ્સ જાતે નક્કી કરે છે.
મુખ્ય સારાંશ
Kubernetes શીખવામાં થોડો સમય લાગે છે. શરૂઆતમાં તેની પરિભાષા જટિલ લાગે છે. તેમાં ઘણા ચાલતા ભાગો છે, અને ડિસ્ટ્રિબ્યુટેડ સિસ્ટમનું ડીબગિંગ કરવું એ સિંગલ સર્વરના ડીબગિંગ કરતા કુદરતી રીતે જ વધુ અઘરું છે. પરંતુ તેનો ફાયદો ઓપરેશનલ શાંતિ છે. તમે વ્યક્તિગત મશીનોનું સતત ધ્યાન રાખવાનું બંધ કરો છો. તમે રાત્રે 3 વાગ્યે સર્વિસ બંધ થાય ત્યારે તમારા સ્ટાર્ટઅપ સ્ક્રિપ્ટ્સ કામ કરે તેવી પ્રાર્થના કરવાનું બંધ કરો છો. તમે ડિફોલ્ટ રીતે નિષ્ફળતા માટે ડિઝાઇન કરવાનું શરૂ કરો છો, એવું માનીને કે નોડ્સ નિષ્ફળ જશે, અને તમારી એપ્લિકેશનને સુરક્ષિત રાખવા માટે ઓર્કેસ્ટ્રેટર પર વિશ્વાસ કરો છો. માનસિકતામાં આ ફેરફાર—કંઈ ન તૂટે તેવી આશા રાખવાથી લઈને સિસ્ટમ ખામીઓને સંભાળી શકે છે તે જાણવા સુધી—તે જ આ મહેનતને સાર્થક બનાવે છે.
Source: What Is Kubernetes? Kubernetes Explained in 15 Mins
Optional learning community: GyaanSetu AI on Telegram