Kubernetes ट्यूटोरियल: एप्लिकेशन डिप्लॉय करने के लिए शुरुआती मार्गदर्शिका

Kubernetes की मूल बातें: Pods, Deployments, Services, और Namespaces

तो, अब जब हमने एक क्लस्टर सेट कर लिया है और यह जाँच लिया है कि सब कुछ काम कर रहा है, तो अपनी पहली एप्लिकेशन बनाने का समय है।

लेकिन पहली एप्लिकेशन बनाने से पहले, Kubernetes की बुनियादी बातें समझना ज़रूरी है। यदि आप Kubernetes का और गहरा परिचय चाहते हैं, तो मैं सलाह दूँगा कि आप Introduction to Kubernetes कोर्स देखें।

Kubernetes में सबसे बुनियादी अवधारणाएँ Pods, Deployments, और Services हैं। इन तीन संसाधन प्रकारों को जानना आपको शक्तिशाली एप्लिकेशन बनाने में मदद कर सकता है। इसलिए, आइए इन्हें थोड़ा विस्तार से समझें।

Pods क्या होते हैं?

Pod Kubernetes में सबसे छोटी डिप्लॉय की जा सकने वाली इकाई है। यह एक या अधिक आपस में कड़े रूप से जुड़े कंटेनर्स को समान स्टोरेज, नेटवर्क और namespace के साथ चलाती है। एक Pod हमेशा किसी Kubernetes node पर शेड्यूल की जाती है. 

आप परिभाषित कर सकते हैं कि आपके Pod को कितने संसाधन (जैसे CPU और मेमोरी) मिलने चाहिए। 

दो कंटेनरों वाली एक उदाहरण एप्लिकेशन हो सकती है—आपकी एप्लिकेशन कंटेनर और एक सहायक कंटेनर जो लॉग्स को एकत्रित करके कहीं भेज देता है। 

Pod की विशेषताएँ:

• एकल इंस्टेंस: प्रत्येक Pod आपकी एप्लिकेशन का एक एकल इंस्टेंस चलाती है।
• स्वभाव से क्षणिक: Pods अस्थायी होने के लिए डिज़ाइन की गई हैं और यदि वे फेल हों या अपडेट हों, तो उन्हें बदल दिया जाता है।

Pod बनाने का एक उदाहरण YAML:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80संचालित द्वारा

इसके बाद आप kubectl का उपयोग करके Pod इंस्टॉल कर सकते हैं:

kubectl apply -f pod.yamlसंचालित द्वारा

यह my-pod नाम का एक Pod शुरू करेगा, जो आपके लिए nginx वेब सर्वर चलाएगा।

Deployments क्या होते हैं?

Deployment एक उच्च-स्तरीय Kubernetes ऑब्जेक्ट है जिसका उपयोग Pods के जीवनचक्र को प्रबंधित करने के लिए किया जाता है। यह सुनिश्चित करता है कि इच्छित संख्या में Pod प्रतिलिपियाँ चल रही हों, और अपडेट तथा रोलबैक को संभालता है. 

Deployment की विशेषताएँ:

• Replica प्रबंधन: सुनिश्चित करता है कि हमेशा इच्छित संख्या में pods चल रहे हों।
• Self-healing: अस्वस्थ Pods को स्वतः बदल देता है।
• Rolling updates: एप्लिकेशन संस्करण को बिना डाउनटाइम के चरणबद्ध तरीके से अपडेट करता है (यदि कॉन्फ़िगर किया गया हो)।

आइए देखें कि एक Deployment YAML फ़ाइल कैसी दिखेगी जो फिर से nginx वेब सर्वर बनाए, लेकिन इस बार तीन replicas के साथ:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80संचालित द्वारा

आप उस Deployment को kubectl से इंस्टॉल कर सकते हैं:

kubectl apply -f deployment.yamlसंचालित द्वारा

ऊपर दिया गया कॉन्फ़िगरेशन nginx-deployment नाम का एक Deployment बनाएगा, जो तीन Pods बनाएगा, और प्रत्येक Pod nginx कंटेनर चलाएगा. 

Services क्या होती हैं?

अब आइए आखिरी हिस्से पर आएँ: Services. 

Service एक abstraction है जो Pods को स्थिर नेटवर्किंग एक्सेस प्रदान करती है, चाहे उनकी IP एड्रेस बदल भी जाएँ। यह आपकी एप्लिकेशन और बाहरी क्लाइंट्स के बीच पुल का काम करती है. 

लेकिन इसकी ज़रूरत क्यों है? प्रत्येक Pod का अपना IP पता होता है। तो हम सीधे उस IP पते का उपयोग क्यों नहीं कर सकते? 

हम कर सकते हैं! लेकिन हमें करना नहीं चाहिए। क्यों? 

क्योंकि Pod क्षणिक होती है; जब आपका Pod अस्वस्थ होता है तो Deployment उसे समाप्त कर देता है और नया Pod स्केल अप करता है। नए Pod का IP पता अलग होगा। इसका मतलब यह होगा कि आपकी एप्लिकेशन का उपयोग करने वाला क्लाइंट हर बार Pod क्रैश होने पर IP पता बदलता रहे, जो अक्सर हो सकता है।

यहीं Service काम आती है: यह किसी विशेष लेबल से मेल खाने वाले सभी Pods को ढूँढती है और स्वचालित रूप से ट्रैफ़िक उन तक रूट करती है। यदि कोई Pod अस्वस्थ हो जाए, तो Service उस Pod को ट्रैफ़िक भेजना बंद कर देती है। और यदि कोई नया Pod आता है, तो वह नए Pod को ट्रैफ़िक भेजना शुरू कर देती है. 

Service आपके Deployment की सभी replicas के बीच ट्रैफ़िक वितरित भी करती है, जो शानदार है क्योंकि इसका मतलब है कि आप अपनी एप्लिकेशन के और इंस्टेंस बनाकर ट्रैफ़िक बाँट सकते हैं, और यह सब एप्लिकेशन लॉजिक में संभालने की ज़रूरत नहीं पड़ती।

Services के प्रकार:

• ClusterIP (डिफ़ॉल्ट): Service को क्लस्टर के अंदर एक्सपोज़ करता है।
• NodePort: Service को ऐसे पोर्ट पर एक्सपोज़ करता है जो क्लस्टर के बाहर से भी एक्सेस किया जा सके।
• LoadBalancer: क्लाउड प्रदाताओं के साथ एकीकृत होकर Service को लोड बैलेंसर के माध्यम से एक्सपोज़ करता है।

क्लस्टर के बाहर हमारे nginx वेब सर्वर को एक्सपोज़ करने का उदाहरण YAML:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePortसंचालित द्वारा

आप फिर से kubectl का उपयोग करके उस Service को बना सकते हैं:

kubectl apply -f service.yamlसंचालित द्वारा

यह Service अब Port 80 पर app=nginx लेबल वाले सभी Pods को आने वाले ट्रैफ़िक का वितरण करेगी. 

यदि आप अपने नए बने Service पर describe कमांड चलाएँ, तो आपको अब तीन endpoints दिखने चाहिए, जहाँ प्रत्येक endpoint वर्तमान में चल रहे किसी Pod का IP पता दर्शाता है:

kubectl describe service nginx-serviceसंचालित द्वारा

ऊपर दी गई कमांड का आउटपुट कुछ ऐसा दिखना चाहिए: 

Name:                     nginx-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.104.53.131
IPs:                      10.104.53.131
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  32256/TCP
Endpoints:                10.244.0.5:80,10.244.0.6:80,10.244.0.7:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>संचालित द्वारा

Pods, Deployments, और Services के बीच संबंध

तो, संक्षेप में:

• Pods: व्यक्तिगत एप्लिकेशन इंस्टेंस का प्रतिनिधित्व करते हैं।
• Deployments: Pods के जीवनचक्र का प्रबंधन करते हैं और सुनिश्चित करते हैं कि वे स्वस्थ हों।
• Services: Pods तक स्थिर एक्सेस प्रदान करती हैं और बाहरी या आंतरिक संचार सक्षम करती हैं।

Namespaces क्या होते हैं?

Kubernetes में Namespaces आपको क्लस्टर के भीतर संसाधनों को व्यवस्थित और अलग-थलग करने की सुविधा देते हैं। आप इन्हें एक ही भौतिक क्लस्टर में वर्चुअल क्लस्टर की तरह समझ सकते हैं. 

Namespaces उपयोग करने के लाभ:

• Separation of concerns: अलग-अलग टीमें या एप्लिकेशन अपने-अपने namespace में बिना दूसरों को प्रभावित किए काम कर सकते हैं. 
• Resource प्रबंधन: आप विभिन्न namespaces के लिए resource quotas और सीमाएँ निर्धारित कर सकते हैं।
• सुरक्षा और एक्सेस नियंत्रण: नीतियाँ namespace स्तर पर लागू की जा सकती हैं।

डिफ़ॉल्ट रूप से, Kubernetes में कुछ इन-बिल्ट namespaces आते हैं:

• default: डिफ़ॉल्ट namespace जहाँ संसाधन बनाए जाते हैं, जब तक कि अन्यथा निर्दिष्ट न किया गया हो
• kube-system: आंतरिक Kubernetes घटकों (जैसे, API server, scheduler, आदि) के लिए उपयोग होता है।
• kube-public: सार्वजनिक रूप से पढ़ा जा सकने वाला namespace।
• kube-node-lease: node heartbeats को ट्रैक करने के लिए उपयोग होता है।

आप एक YAML फ़ाइल का उपयोग करके namespace बना सकते हैं: 

apiVersion: v1
kind: Namespace
metadata:
  name: my-namespaceसंचालित द्वारा

इसे namespace.yaml नामक फ़ाइल में सहेजें और इस प्रकार लागू करें: 

kubectl apply -f namespace.yamlसंचालित द्वारा

नीचे दी गई कमांड चलाने पर, आपको सभी सूचीबद्ध डिफ़ॉल्ट namespaces और नया बनाया गया namespace दिखना चाहिए: 

kubectl get namespacesसंचालित द्वारा

इसके बाद आप अपने संसाधन की metadata सेक्शन में namespace सेट करके उस namespace में संसाधन बना सकते हैं. 

यदि हम अपने नए बनाए गए namespace में nginx Deployment बनाना चाहें, तो वह कुछ ऐसा दिखेगा:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: my-namespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80संचालित द्वारा

अब, आपको यह स्पष्ट रूप से बताना होगा कि आप अपने नए namespace से संसाधन प्राप्त करना चाहते हैं, और इसके लिए -n आर्गुमेंट का उपयोग करें: 

kubectl get deployment -n my-namespaceसंचालित द्वारा

Kubernetes के साथ अपनी पहली एप्लिकेशन का प्रबंधन

ठीक है, अब जब आप Kubernetes की बुनियादी अवधारणाओं से परिचित हैं, तो हमारी पहली वेब एप्लिकेशन को Kubernetes पर डिप्लॉय करने और उसे एक्सेस करने का समय है. 

इस अध्याय में, हम एक nginx वेब सर्वर बनाएँगे, उस वेब सर्वर को Service के ज़रिए बाहरी दुनिया के लिए एक्सपोज़ करेंगे, हाई-ट्रैफ़िक व्यवहार का अनुकरण करने के लिए एप्लिकेशन को स्केल करेंगे, और नई संस्करण पर rolling update का उपयोग करके एप्लिकेशन को अपडेट करेंगे।

तो, चलिए मज़ेदार काम शुरू करते हैं!

एक साधारण वेब एप्लिकेशन डिप्लॉयमेंट बनाना

पहला चरण हमारे वेब सर्वर के लिए एक Deployment बनाना है जो Nginx इमेज का उपयोग करके एक कंटेनर बनाए।

नीचे दिया गया कोड कॉपी करें और nginx-deployment.yaml नामक फ़ाइल में सहेजें।

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80संचालित द्वारा

फिर, निम्नलिखित कमांड का उपयोग करके अपने क्लस्टर पर उस Deployment को लागू करें:

kubectl apply -f nginx-deployment.yamlसंचालित द्वारा

इसके बाद आप यह सत्यापित कर सकते हैं कि Pod चल रहा है: 

kubectl get podsसंचालित द्वारा

Service के साथ एप्लिकेशन को एक्सपोज़ करना

हमें nginx वेब सर्वर को Service के ज़रिए बाहरी दुनिया के लिए एक्सपोज़ करना होगा। इसके लिए, हम NodePort प्रकार की Service बना रहे हैं, क्योंकि हम Kubernetes क्लस्टर के बाहर अपनी लोकल मशीन से nginx वेब सर्वर तक पहुँचना चाहते हैं।

तो nginx-service.yaml नाम की फ़ाइल बनाएँ और निम्न सामग्री जोड़ें:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePortसंचालित द्वारा

इसके बाद आप नीचे दी गई कमांड से Service लागू कर सकते हैं:

kubectl apply -f nginx-service.yamlसंचालित द्वारा

अंत में, आप minikube का उपयोग करके अपने nginx वेब सर्वर का URL प्राप्त कर सकते हैं:

minikube service nginx-service --urlसंचालित द्वारा

उस URL को अपने ब्राउज़र में खोलें, और आपको अपने nginx वेब सर्वर का वेलकम पेज दिखना चाहिए।

लोकल ब्राउज़र में nginx वेब सर्वर के वेलकम पेज का स्क्रीनशॉट।

एप्लिकेशन को स्केल करना

तो, हमारा एक Pod चल रहा है। लेकिन हमारी वेबपेज पर बहुत अधिक उपयोगकर्ता आ सकते हैं। यही कारण है कि Kubernetes में, आप अपनी एप्लिकेशन को जल्दी से स्केल कर सकते हैं ताकि अधिक Pods चल सकें. 

Service स्वचालित रूप से उस Deployment से संबंधित सभी Pods का पता लगा लेगी और फिर nginx वेब सर्वर चलाने वाले सभी Pods पर आने वाले अनुरोधों को लोड बैलेंस करेगी। यदि बहुत अधिक ट्रैफ़िक आता है, तो यह हमारे वेब पेज के समग्र प्रदर्शन में सुधार करने में मदद करता है।

तो, नीचे दी गई कमांड का उपयोग करके अपनी एप्लिकेशन को 3 replicas तक स्केल करें:

kubectl scale deployment nginx-deployment --replicas=3संचालित द्वारा

अब आप फिर से सभी चल रहे Pods की सूची प्राप्त कर सकते हैं, जो तीन होने चाहिए:

kubectl get podsसंचालित द्वारा

आप नीचे दी गई कमांड का उपयोग करके उन सभी endpoints को भी प्राप्त कर सकते हैं जिनसे हमारा nginx-service जुड़ा है। इसमें तीन endpoints दिखने चाहिए, और प्रत्येक endpoint अपना अलग आंतरिक क्लस्टर IP पता होता है:

kubectl get endpoints nginx-serviceसंचालित द्वारा

Rolling updates

अब, Kubernetes का उपयोग करने का एक और बड़ा लाभ है: Rolling updates।

Rolling update का उद्देश्य आपकी वेब एप्लिकेशन में किसी भी डाउनटाइम से बचना है। बस कल्पना करें कि यदि Amazon जैसी कंपनियों का वेब पेज हर बार नए संस्करण के रोलआउट पर डाउन हो जाए तो कितना वित्तीय नुकसान होगा।

Rolling update का उपयोग करते हुए, Kubernetes एक नया Pod स्केल-अप करता है, यह जाँचता है कि वह स्वस्थ है या नहीं, और फिर पुराने वाले को स्केल-डाउन करता है. 

डिफ़ॉल्ट रूप से, Kubernetes सुनिश्चित करता है कि कम-से-कम 75% इच्छित Pods चालू और चल रहे हों, और अधिकतम 25% अनुपलब्ध हों। इसका मतलब है कि हमारे मामले में, जहाँ तीन replicas चल रहे हैं, Kubernetes एक समय में केवल एक नया Pod जोड़ेगा, यह जाँचेगा कि वह स्वस्थ है या नहीं, और फिर यदि स्वस्थ है तो एक अन्य Pod को स्केल-डाउन करेगा। यह प्रक्रिया तब तक दोहराई जाएगी जब तक कि सभी Pods नए संस्करण पर अपडेट न हो जाएँ।

तो अब आइए अपने nginx इमेज का संस्करण latest से बदलकर 1.23 कर दें:

kubectl set image deployment/nginx-deployment nginx=nginx:1.23संचालित द्वारा

इसके बाद आप rollout स्थिति की निगरानी इस प्रकार कर सकते हैं: 

kubectl rollout status deployment/nginx-deploymentसंचालित द्वारा

आउटपुट कुछ ऐसा दिखना चाहिए: 

Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled outसंचालित द्वारा

और rollout के दौरान भी, आपकी वेब पेज बिना किसी डाउनटाइम के हर समय सुलभ रहता है!

क्या यह शानदार नहीं है?

Kubernetes संसाधनों का प्रबंधन

Kubernetes सभी प्रकार के संसाधनों का निरीक्षण, संशोधन और हटाने के लिए शक्तिशाली उपकरण प्रदान करता है। संसाधनों का प्रभावी ढंग से प्रबंधन समझना बेहतर ट्रबलशूटिंग, संसाधन आवंटन और समग्र क्लस्टर मेंटेनेंस सुनिश्चित करता है. 

इस खंड में, हम अन्य आवश्यक कमांड्स पर नज़र डालेंगे जो आपको संसाधनों का प्रभावी प्रबंधन करने और समस्या होने की स्थिति में ट्रबलशूटिंग में मदद करते हैं।

क्लस्टर संसाधनों को देखना

किसी भी संसाधन को बदलने से पहले, अपने क्लस्टर में वर्तमान में चल रहे संसाधनों को देखना और जाँचना ज़रूरी है।

उदाहरण के लिए, आप सभी चल रहे Pods, Services और Deployments की सूची बना सकते हैं ताकि देख सकें कि आपके क्लस्टर में क्या चल रहा है: 

# list running Pods
kubectl get pods

# list running Services 
kubectl get services

# list running Deployments
kubectl get deploymentsसंचालित द्वारा

यदि आप किसी विशेष संसाधन में और गहराई में जाना चाहते हैं, तो आप describe कमांड का उपयोग कर सकते हैं:

kubectl describe deployment nginx-deploymentसंचालित द्वारा

यह अधिक जानकारी दिखाएगा, जिनमें rolling updates, स्केलिंग, या इमेज पुल इवेंट्स शामिल हैं। कुछ गड़बड़ होने पर यह पहला स्थान है जहाँ आप जा सकते हैं।

आप नीचे दी गई कमांड का उपयोग करके किसी चल रहे Pod के लॉग्स भी देख सकते हैं ताकि यह समझ सकें कि उसके अंदर क्या चल रहा है:

kubectl logs <pod-name>संचालित द्वारा

संसाधन हटाना

यदि संसाधनों का उपयोग नहीं हो रहा हो, तो उन्हें साफ़ करना भी आवश्यक है ताकि नए एप्लिकेशनों के लिए क्लस्टर संसाधन मुक्त हो सकें. 

आप एक Pod को इस प्रकार हटा सकते हैं:

kubectl delete pod <pod-name>संचालित द्वारा

हम अपने किसी nginx pod के लिए ऐसा कर सकते हैं। हालाँकि, नया Pod तुरंत स्केल-अप हो जाना चाहिए, क्योंकि वे एक Deployment के माध्यम से प्रबंधित होते हैं, जो हमेशा तीन replicas को चालू रखने की कोशिश करता है. 

तो यहाँ, हमें nginx-deployment को हटाने की ज़रूरत होगी: 

kubectl delete deployment nginx-deploymentसंचालित द्वारा

यह कमांड चलाने के बाद, सभी चल रहे nginx Pods हटा दिए जाने चाहिए. 

हम एक Namespace में सभी संसाधन भी हटा सकते हैं। निम्न कमांड डिफ़ॉल्ट रूप से default Namespace में बनाए गए हमारे सभी संसाधनों को हटा देगी:

kubectl delete all --allसंचालित द्वारा

निष्कर्ष

बधाई हो! आप अंत तक पहुँच गए हैं और सफलतापूर्वक Kubernetes में अपने पहले कदम उठा लिए हैं. 

इस ट्यूटोरियल का पालन करके, आपने सीखा कि कैसे:

• minikube का उपयोग करके लोकल Kubernetes क्लस्टर सेट करें।
• Pods, Deployments, Services, और Namespaces (Kubernetes के आवश्यक निर्माण ब्लॉक्स) के साथ काम करें।
• Kubernetes के भीतर एक सरल वेब एप्लिकेशन को डिप्लॉय और प्रबंधित करें।
• एप्लिकेशन को डायनेमिक रूप से स्केल करें और बिना डाउनटाइम के rolling updates करें।
• Kubernetes संसाधनों को सूचीबद्ध, विवरण देखने और हटाने के माध्यम से प्रबंधित करें।

शुरुआत में Kubernetes जटिल लग सकता है (कम-से-कम मुझे तो लगा)। लेकिन इसे मौलिक अवधारणाओं में बाँट देने से यह अधिक सहज हो जाता है. 

प्रयोग करते रहें और और अधिक एप्लिकेशन डिप्लॉय करें. 

Kubernetes सीखने का सबसे अच्छा तरीका करके सीखना है, तो बनाना शुरू करें!

अपनी Kubernetes कौशल को और बेहतर करने के लिए, इन पर विचार करें:

• ConfigMaps और Secrets के साथ काम करना: कॉन्फ़िगरेशन सेटिंग्स को सुरक्षित रूप से संग्रहीत और प्रबंधित करें।
• Persistent volumes: ऐसे डेटा को संग्रहीत करना सीखें जो Pod रीस्टार्ट के बाद भी बना रहे।
• Networking और ingress controllers: डोमेन-आधारित रूटिंग सेट करें और बाहरी ट्रैफ़िक को मैनेज करें।
• Helm: जटिल एप्लिकेशनों को पैकेज और कुशलतापूर्वक डिप्लॉय करने के लिए Helm charts का उपयोग करें।
• क्लाउड में Kubernetes: AWS EKS, Azure AKS, या Google GKE जैसी managed Kubernetes सेवाओं के साथ प्रयोग करें।

अंत में, DataCamp पर Containerization and Virtualization with Docker and Kubernetes ट्रैक Docker और Kubernetes दोनों का अभ्यास करने के लिए एक उत्कृष्ट संसाधन है।