Kubernetes के साथ ऑर्केस्ट्रेशन – Kubernetes का परिचय और इसका उपयोग

आज के मॉडर्न एप्लिकेशन अक्सर कई कंटेनरों में चलते हैं, जिनका प्रबंधन और ऑर्केस्ट्रेशन करना जटिल हो सकता है। Kubernetes एक ओपन-सोर्स प्लेटफ़ॉर्म है, जो कंटेनरों के क्लस्टर को मैनेज करने और स्केल करने में मदद करता है। Kubernetes का उपयोग करने से आप मल्टी-कंटेनर एप्लिकेशन को ऑटोमेट कर सकते हैं, जिससे इनकी विश्वसनीयता और लचीलापन बढ़ जाता है।

इस पोस्ट में, हम समझेंगे कि Kubernetes क्या है, यह कैसे काम करता है, और इसे कंटेनर ऑर्केस्ट्रेशन के लिए कैसे सेटअप किया जाता है। अगर आप अपने कंटेनराइज़्ड एप्लिकेशन को बड़े पैमाने पर मैनेज करना चाहते हैं, तो Kubernetes एक महत्वपूर्ण टूल है।

Kubernetes क्या है? (What is Kubernetes?)

Kubernetes (K8s) एक ओपन-सोर्स कंटेनर ऑर्केस्ट्रेशन प्लेटफ़ॉर्म है, जो कंटेनरों के समूह (cluster) को मैनेज और ऑटोमेट करने में मदद करता है। जब आपके एप्लिकेशन कई कंटेनरों में चलते हैं, तो उन्हें मैन्युअली स्केल और मैनेज करना मुश्किल हो जाता है। Kubernetes इस प्रक्रिया को सरल और कुशल बनाता है।

Kubernetes की मदद से आप कंटेनरों को ऑटोमेट कर सकते हैं, उन्हें स्केल कर सकते हैं, और सुनिश्चित कर सकते हैं कि आपका एप्लिकेशन हमेशा उपलब्ध हो। यह कंटेनरों को आसानी से एक से अधिक नोड्स (servers) पर वितरित और चलाने में सक्षम बनाता है।

Kubernetes के प्रमुख कार्य:

1. ऑर्केस्ट्रेशन (Orchestration):
   Kubernetes कई कंटेनरों को एक साथ रन करता है और उनके बीच समन्वय स्थापित करता है, जिससे वे एक बड़े एप्लिकेशन का हिस्सा बन सकते हैं।
2. स्केलिंग (Scaling):
   Kubernetes की मदद से आप अपने एप्लिकेशन को ऑटोमेटिकली स्केल कर सकते हैं, जब सिस्टम पर लोड बढ़ता या घटता है। Kubernetes कंटेनरों की संख्या को बढ़ाने या घटाने की प्रक्रिया को हैंडल करता है।
3. लोड बैलेंसिंग (Load Balancing):
   Kubernetes एप्लिकेशन के लिए लोड बैलेंसिंग का काम करता है, जिससे प्रत्येक कंटेनर पर समान रूप से लोड वितरित होता है। इससे एप्लिकेशन का प्रदर्शन स्थिर बना रहता है।
4. सेल्फ-हीलिंग (Self-healing):
   Kubernetes कंटेनरों की निगरानी करता है और यदि कोई कंटेनर फेल हो जाता है, तो उसे ऑटोमेटिकली फिर से रन करता है। यह सुनिश्चित करता है कि आपका एप्लिकेशन हमेशा उपलब्ध हो।
5. क्लस्टर मैनेजमेंट (Cluster Management):
   Kubernetes कंटेनरों के क्लस्टर को मैनेज करता है, जिसमें कई नोड्स पर कंटेनरों का वितरण और प्रबंधन होता है। यह सुनिश्चित करता है कि कंटेनर हमेशा सही तरीके से वितरित और रन किए जाएं।

Kubernetes का उपयोग क्यों करें?

1. ऑटोमेशन:
   Kubernetes कंटेनरों के सभी महत्वपूर्ण कार्यों को ऑटोमेट कर देता है, जिससे आपको मैन्युअल हस्तक्षेप की ज़रूरत नहीं होती।
2. स्केलेबिलिटी:
   चाहे आपका एप्लिकेशन छोटा हो या बड़े पैमाने पर, Kubernetes इसे कुशलता से स्केल कर सकता है। आप ट्रैफिक बढ़ने पर कंटेनरों को बढ़ा सकते हैं और जरूरत कम होने पर उन्हें घटा सकते हैं।
3. पोर्टेबिलिटी:
   Kubernetes को आप किसी भी क्लाउड प्लेटफ़ॉर्म (AWS, Google Cloud, Azure) या ऑन-प्रेमाइसेस सिस्टम पर चला सकते हैं। इससे यह आपके एप्लिकेशन के लिए एक लचीला और पोर्टेबल विकल्प बनता है।
4. विश्वसनीयता:
   Kubernetes आपके एप्लिकेशन की उपलब्धता को सुनिश्चित करता है। अगर कोई कंटेनर क्रैश हो जाता है, तो यह उसे तुरंत रिप्लेस कर देता है, जिससे आपका एप्लिकेशन डाउन नहीं होता।

Kubernetes का आर्किटेक्चर (Kubernetes Architecture: Pods, Nodes, Clusters)

Kubernetes का आर्किटेक्चर कंटेनरों को प्रभावी ढंग से ऑर्केस्ट्रेट और मैनेज करने के लिए विभिन्न घटकों (components) से मिलकर बना होता है। इसमें मुख्य रूप से Pods, Nodes, और Clusters शामिल होते हैं, जो मिलकर Kubernetes सिस्टम को कार्यात्मक बनाते हैं। आइए, इन प्रमुख घटकों को विस्तार से समझते हैं:

1. क्लस्टर (Cluster):

• Cluster Kubernetes का सबसे बड़ा घटक होता है। यह कई Nodes का एक समूह होता है, जहाँ Kubernetes कंटेनरों को रन, मैनेज, और स्केल करता है। एक क्लस्टर में कंटेनरों का पूरा जीवनचक्र मैनेज होता है।
• क्लस्टर के अंदर, कंटेनरों का समन्वय, लोड बैलेंसिंग, और स्केलिंग होता है, जिससे एप्लिकेशन के विभिन्न हिस्से बिना रुकावट के चलते रहें।
• क्लस्टर में दो प्रकार के Nodes होते हैं:
  • मास्टर नोड (Master Node): यह क्लस्टर का प्रमुख नोड होता है, जो पूरे क्लस्टर को कंट्रोल और मैनेज करता है।
  • वर्कर नोड्स (Worker Nodes): ये वे नोड्स होते हैं, जहाँ कंटेनर वास्तव में रन होते हैं। मास्टर नोड इन वर्कर नोड्स को निर्देश देता है।

2. नोड्स (Nodes):

• Node वह मशीन होती है (फिजिकल या वर्चुअल) जहाँ Kubernetes कंटेनर रन करता है। एक क्लस्टर में कई Nodes हो सकते हैं, और प्रत्येक Node पर कई कंटेनर रन हो सकते हैं।
• प्रत्येक Node में एक Kubelet नामक एजेंट रन होता है, जो मास्टर नोड के निर्देशों के आधार पर कंटेनरों को मैनेज करता है।
• Nodes में मुख्य रूप से ये घटक होते हैं:
  • Kubelet: यह मास्टर नोड से निर्देश प्राप्त करके कंटेनरों को रन और मैनेज करता है।
  • Kube-proxy: यह नेटवर्किंग घटक है, जो प्रत्येक Node पर नेटवर्क ट्रैफिक का प्रबंधन करता है।
  • Container Runtime: यह वह सॉफ़्टवेयर है (जैसे Docker या containerd) जो कंटेनरों को रन करने के लिए ज़रूरी होता है।

3. पॉड्स (Pods):

• Pod Kubernetes का सबसे छोटा और बुनियादी घटक होता है। एक Pod के अंदर एक या एक से अधिक कंटेनर होते हैं, जो एक साथ रन होते हैं और एक ही नेटवर्क स्पेस शेयर करते हैं।
• Pods कंटेनरों का एक उच्चतम स्तर का समूह है, जो Kubernetes द्वारा मैनेज किया जाता है। अगर कोई कंटेनर फेल हो जाता है, तो Kubernetes पूरे Pod को फिर से रन कर सकता है।
• Pods की विशेषताएँ:
  • प्रत्येक Pod के पास एक यूनिक IP एड्रेस होता है।
  • एक Pod में मौजूद सभी कंटेनर एक-दूसरे से सीधे कम्युनिकेशन कर सकते हैं।
  • Pods को स्केल किया जा सकता है, जिससे एप्लिकेशन के प्रदर्शन को बेहतर बनाया जा सकता है।

Kubernetes आर्किटेक्चर का कार्य:

Kubernetes का आर्किटेक्चर इस तरह डिज़ाइन किया गया है कि यह कंटेनरों को ऑटोमेटिकली स्केल, मैनेज, और रिपेयर कर सके। इसमें मास्टर नोड पूरे क्लस्टर को नियंत्रित करता है और वर्कर नोड्स पर Pods को रन करता है। जब भी किसी कंटेनर को स्केल करने या उसकी स्थिति मॉनिटर करने की ज़रूरत होती है, मास्टर नोड उन निर्देशों को वर्कर नोड्स तक पहुँचाता है।

Kubernetes आर्किटेक्चर के फायदे:

1. स्केलेबिलिटी (Scalability):
   Kubernetes का आर्किटेक्चर एप्लिकेशन को बड़े पैमाने पर स्केल करने की क्षमता प्रदान करता है। यह ऑटोमेटिकली कंटेनरों को स्केल कर सकता है जब सिस्टम पर लोड बढ़ता है।
2. लचीलापन (Flexibility):
   Kubernetes में आप आसानी से नए नोड्स जोड़ सकते हैं या Pods को स्केल कर सकते हैं। इसके आर्किटेक्चर के कारण एप्लिकेशन की स्केलेबिलिटी और पोर्टेबिलिटी में वृद्धि होती है।
3. फेलओवर और सेल्फ-हीलिंग (Failover and Self-Healing):
   Kubernetes स्वचालित रूप से फेल हुए कंटेनरों को फिर से रन करता है और एप्लिकेशन की निरंतरता बनाए रखता है, जिससे आपका एप्लिकेशन हमेशा चालू रहता है।

एक सरल एप्लीकेशन को Kubernetes में डिप्लॉय करना (Deploying a Simple App on Kubernetes)

Kubernetes के ज़रिए एप्लिकेशन को डिप्लॉय करना आसान और कुशल प्रक्रिया है। इस सेक्शन में हम देखेंगे कि कैसे एक सरल एप्लिकेशन को Kubernetes क्लस्टर पर डिप्लॉय किया जाता है। हम Nginx वेब सर्वर को एक उदाहरण के रूप में उपयोग करेंगे, जो Kubernetes के माध्यम से कंटेनर के अंदर रन किया जाएगा।

कदम 1: Kubernetes क्लस्टर सेटअप करें

• सबसे पहले, आपको Kubernetes क्लस्टर की ज़रूरत होगी। अगर आपने पहले से क्लस्टर सेटअप नहीं किया है, तो आप इसे मिनीक्यूब (Minikube) या किसी भी क्लाउड प्लेटफ़ॉर्म (जैसे Google Kubernetes Engine, AWS EKS, Azure AKS) के माध्यम से सेटअप कर सकते हैं।
  • Minikube से लोकल क्लस्टर सेटअप करने के लिए:

    minikube start
    

     

कदम 2: Nginx डिप्लॉयमेंट YAML फाइल बनाएं

• अब आपको अपने एप्लिकेशन (इस केस में Nginx) के लिए एक डिप्लॉयमेंट YAML फाइल तैयार करनी होगी, जिसमें एप्लिकेशन की कंफिगरेशन और कंटेनर की जानकारी होगी।
  • nginx-deployment.yaml नाम की एक YAML फाइल बनाएं और उसमें निम्नलिखित कंटेंट डालें:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-deployment
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:latest
            ports:
            - containerPort: 80
    

     

कदम 3: एप्लिकेशन को डिप्लॉय करें

• YAML फाइल तैयार हो जाने के बाद, आप इसे Kubernetes क्लस्टर में डिप्लॉय कर सकते हैं। इसके लिए निम्नलिखित कमांड का उपयोग करें:

  kubectl apply -f nginx-deployment.yaml
  

  यह कमांड Kubernetes क्लस्टर में Nginx एप्लिकेशन को डिप्लॉय कर देगा, और आप देखेंगे कि दो replicas (कंटेनर) रन हो रहे हैं, जैसा कि YAML फाइल में परिभाषित किया गया है।

कदम 4: डिप्लॉयमेंट को चेक करें

• अब आप यह देख सकते हैं कि आपका एप्लिकेशन सफलतापूर्वक डिप्लॉय हुआ है या नहीं। इसके लिए आप निम्नलिखित कमांड का उपयोग कर सकते हैं:

  kubectl get deployments
  kubectl get pods
  

   

• यह कमांड आपको डिप्लॉयमेंट और रन हो रहे Pods की जानकारी देगा। अगर सबकुछ सही सेटअप किया गया है, तो आप देखेंगे कि Nginx के दो Pods रन कर रहे हैं।

कदम 5: सर्विस क्रिएट करके एक्सेस करें

• एप्लिकेशन को एक्सेस करने के लिए आपको एक Service क्रिएट करनी होगी, जो बाहरी ट्रैफिक को Pods तक पहुंचाएगी। इसके लिए एक YAML फाइल तैयार करें:
  • nginx-service.yaml नाम की एक YAML फाइल बनाएं:

    apiVersion: v1
    kind: Service
    metadata:
      name: nginx-service
    spec:
      selector:
        app: nginx
      ports:
      - protocol: TCP
        port: 80
        targetPort: 80
      type: LoadBalancer
    

     

  • इस फाइल को Kubernetes में अप्लाई करें:

    kubectl apply -f nginx-service.yaml
    

     

कदम 6: एप्लिकेशन को एक्सेस करें

• अब आप अपने एप्लिकेशन को एक्सेस कर सकते हैं। अगर आप Minikube का उपयोग कर रहे हैं, तो minikube service कमांड का उपयोग करके URL प्राप्त करें:

  minikube service nginx-service
  

   

• यह कमांड आपको एक URL प्रदान करेगा, जहाँ आप ब्राउज़र में Nginx एप्लिकेशन को देख सकते हैं।

एप्लीकेशन को स्केल करना और अपडेट्स को मैनेज करना (Scaling Applications and Managing Updates)

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

एप्लिकेशन को स्केल करना (Scaling Applications)

Kubernetes में स्केलिंग बहुत आसान है। आपको बस यह बताना होता है कि कितने कंटेनर (Pods) चाहिए, और Kubernetes बाकी का काम खुद करता है। उदाहरण के लिए, अगर आपका एप्लिकेशन अधिक ट्रैफिक को संभालने में सक्षम नहीं हो रहा है, तो आप Pods की संख्या बढ़ाकर एप्लिकेशन को स्केल कर सकते हैं।

1. स्केलिंग के लिए कमांड:
   • मान लीजिए कि आप अपने Nginx एप्लिकेशन के Pods की संख्या 2 से 5 करना चाहते हैं। इसके लिए आप निम्नलिखित कमांड का उपयोग कर सकते हैं:

     kubectl scale deployment nginx-deployment --replicas=5
     

      

   • यह कमांड आपके एप्लिकेशन को स्केल करके 5 Pods रन करेगा।
2. ऑटोमैटिक स्केलिंग:
   • Kubernetes ऑटोमेटिक स्केलिंग के लिए Horizontal Pod Autoscaler (HPA) का समर्थन करता है। यह आपके एप्लिकेशन के लोड के आधार पर Pods की संख्या को ऑटोमेटिकली एडजस्ट करता है। HPA सेटअप करने के लिए, आप निम्न कमांड का उपयोग कर सकते हैं:

     kubectl autoscale deployment nginx-deployment --cpu-percent=50 --min=2 --max=10
     

      

   • इस कमांड से Kubernetes आपके एप्लिकेशन के Pods की संख्या को 2 से 10 के बीच ऑटोमेटिकली स्केल करेगा, जब CPU उपयोग 50% से अधिक हो जाएगा।

एप्लिकेशन अपडेट्स को मैनेज करना (Managing Application Updates)

Kubernetes में एप्लिकेशन अपडेट्स को बिना डाउनटाइम के लागू करना बेहद आसान है। आप नए वर्ज़न के कंटेनर इमेज को रोल आउट कर सकते हैं और Kubernetes पुराने Pods को हटाकर नए Pods को ऑटोमेटिकली रन करता है, जिससे यूज़र को किसी तरह की समस्या नहीं होती।

1. Rolling Update:
   • Kubernetes Rolling Updates का उपयोग करता है, जिसमें धीरे-धीरे नए कंटेनर लॉन्च होते हैं और पुराने कंटेनर बंद होते जाते हैं। इससे एप्लिकेशन का अपटाइम बना रहता है।
   • उदाहरण के लिए, अगर आप Nginx एप्लिकेशन को एक नए वर्ज़न में अपडेट करना चाहते हैं, तो आप YAML फाइल में इमेज को अपडेट कर सकते हैं:

     containers:
     - name: nginx
       image: nginx:1.19.6
     

      

   • इसके बाद निम्नलिखित कमांड का उपयोग करें:

     kubectl apply -f nginx-deployment.yaml
     

      

   • Kubernetes धीरे-धीरे नए वर्ज़न को रोल आउट करेगा और पुराने वर्ज़न को हटाएगा।
2. Update Status चेक करना:
   • आप यह भी चेक कर सकते हैं कि आपका अपडेट कब तक पूरा हो जाएगा या उसमें क्या स्थिति है:

     kubectl rollout status deployment/nginx-deployment
     

      

3. Rollback:
   • अगर नए अपडेट में कोई समस्या है, तो Kubernetes में आप Rollback करके पिछले स्थिर वर्ज़न पर वापस जा सकते हैं। इसके लिए आप निम्न कमांड का उपयोग कर सकते हैं:

     kubectl rollout undo deployment/nginx-deployment
     

      

स्केलिंग और अपडेट्स के फायदे:

1. लचीलापन (Flexibility):
   • Kubernetes में स्केलिंग और अपडेट्स के लिए आपको मैन्युअल हस्तक्षेप की आवश्यकता नहीं होती है। यह सिस्टम को ऑटोमेटिकली एडजस्ट कर सकता है, जिससे आपका एप्लिकेशन हमेशा तैयार रहता है।
2. डाउनटाइम से बचाव (No Downtime):
   • Rolling Updates के ज़रिए नए वर्ज़न को लागू करते समय कोई डाउनटाइम नहीं होता। इससे यूज़र एक्सपीरियंस बेहतर बना रहता है।
3. पारदर्शिता और कंट्रोल (Transparency and Control):
   • स्केलिंग और अपडेट्स दोनों की पूरी जानकारी Kubernetes डैशबोर्ड या कमांड लाइन के माध्यम से प्राप्त की जा सकती है, जिससे आपको हर प्रक्रिया का पूरा कंट्रोल मिलता है।

Kubernetes Services के द्वारा नेटवर्किंग (Networking with Kubernetes Services)

जब आप Kubernetes क्लस्टर में एप्लिकेशन डिप्लॉय करते हैं, तो प्रत्येक कंटेनर या Pod का अपना यूनिक IP एड्रेस होता है, लेकिन ये IP एड्रेस डायनामिक होते हैं और Pods के मरने या रिक्रिएट होने पर बदल सकते हैं। इसी वजह से, Kubernetes में Services की अवधारणा आती है, जो Pods के बीच स्थिर नेटवर्किंग और लोड बैलेंसिंग का काम करती हैं। Services यह सुनिश्चित करती हैं कि आपके एप्लिकेशन हमेशा उपलब्ध रहें और सही तरीके से Pods तक ट्रैफिक पहुँचाया जा सके।

Kubernetes Services क्या हैं? (What are Kubernetes Services?)

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

Kubernetes Services के प्रकार:

1. ClusterIP:
   • यह डिफ़ॉल्ट Service प्रकार होता है। ClusterIP एक इंटरनल IP एड्रेस प्रदान करता है, जो केवल Kubernetes क्लस्टर के अंदर ही एक्सेस किया जा सकता है। इसका उपयोग क्लस्टर के अंदर चलने वाली सेवाओं को एक-दूसरे से कनेक्ट करने के लिए किया जाता है।
   • उदाहरण: किसी डेटाबेस सर्वर को वेब एप्लिकेशन से कनेक्ट करना।
2. NodePort:
   • NodePort Service प्रकार में, Kubernetes क्लस्टर के प्रत्येक Node पर एक निश्चित पोर्ट एक्सपोज़ किया जाता है। इस पोर्ट के माध्यम से आप क्लस्टर के बाहर से भी Pods को एक्सेस कर सकते हैं।
   • उदाहरण:

     apiVersion: v1
     kind: Service
     metadata:
       name: my-service
     spec:
       type: NodePort
       selector:
         app: my-app
       ports:
         - port: 80
           targetPort: 8080
           nodePort: 30007
     

      

   • इस YAML फाइल में NodePort सर्विस सेटअप की गई है, जिससे 30007 पोर्ट के माध्यम से क्लस्टर के बाहर से Pods को एक्सेस किया जा सकता है।
3. LoadBalancer:
   • LoadBalancer Service प्रकार का उपयोग तब किया जाता है, जब आप अपने क्लस्टर को बाहरी दुनिया से कनेक्ट करना चाहते हैं, जैसे कि क्लाउड इंफ्रास्ट्रक्चर में। LoadBalancer आपके Pods के बीच लोड को बैलेंस करता है और आपके क्लस्टर के बाहर से ट्रैफिक को सही Pods तक पहुँचाता है।
   • उदाहरण:

     apiVersion: v1
     kind: Service
     metadata:
       name: my-service
     spec:
       type: LoadBalancer
       selector:
         app: my-app
       ports:
         - port: 80
           targetPort: 8080
     

      

4. ExternalName:
   • ExternalName एक विशेष प्रकार की Service होती है, जो आपके क्लस्टर के अंदर किसी DNS नाम को एक बाहरी सेवा (जैसे api.example.com) के साथ मैप करती है। इसका उपयोग तब होता है, जब आप क्लस्टर के बाहर मौजूद सेवाओं से Pods को कनेक्ट करना चाहते हैं।

Kubernetes Service का कार्य:

1. समान ट्रैफिक वितरण (Load Balancing):
   • Service क्लस्टर में उपलब्ध सभी Pods के बीच ट्रैफिक को समान रूप से वितरित करती है। इससे एप्लिकेशन की परफॉर्मेंस बेहतर होती है और लोड किसी एक Pod पर नहीं पड़ता।
2. स्ट्रेटिक IP प्रदान करना (Static IP for Pods):
   • Pods का IP एड्रेस बदलता रहता है, लेकिन Service एक स्थिर IP प्रदान करती है, जिसे एप्लिकेशन हमेशा इस्तेमाल कर सकते हैं। यह नेटवर्किंग को स्थिर और भरोसेमंद बनाता है।
3. DNS Resolution:
   • Kubernetes में Service का एक DNS नाम होता है। जब भी Pods को एक-दूसरे से कनेक्ट करना होता है, तो वे DNS नाम के माध्यम से Service को कॉल कर सकते हैं, जो पीछे से सही Pods तक ट्रैफिक पहुँचाती है।

Kubernetes Service को सेटअप करना (Setting up a Kubernetes Service):

मान लीजिए आपके पास एक एप्लिकेशन डिप्लॉयमेंट है और अब आपको इसे एक Service के साथ एक्सपोज़ करना है। इसके लिए आप एक YAML फाइल बना सकते हैं, जैसे:

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: ClusterIP

इस YAML फाइल में:

• selector वह लेबल है जो Pods को मैप करता है।
• ports एप्लिकेशन के पोर्ट्स को मैप करता है (क्लस्टर पोर्ट को Pods के इंटरनल पोर्ट से)।
• type: ClusterIP इसका मतलब है कि यह सर्विस क्लस्टर के अंदर की नेटवर्किंग के लिए उपयोग होगी।

Service को अप्लाई करने के लिए निम्नलिखित कमांड का उपयोग करें:

kubectl apply -f my-app-service.yaml

Kubernetes Services के फायदे:

1. स्मूद नेटवर्किंग:
   Services स्थिर IP प्रदान करके नेटवर्किंग को आसान और स्थिर बनाती हैं। इससे Pods का IP बदलने पर भी एप्लिकेशन में कोई समस्या नहीं होती।
2. लोड बैलेंसिंग:
   Pods के बीच समान रूप से ट्रैफिक वितरित करने के लिए Service का लोड बैलेंसिंग महत्वपूर्ण होता है, जिससे एप्लिकेशन की परफॉर्मेंस बढ़ती है।
3. क्लस्टर और बाहरी नेटवर्क के बीच कनेक्शन:
   Services क्लस्टर के अंदर और बाहर के नेटवर्क को जोड़ने में मदद करती हैं, जिससे आपका एप्लिकेशन आसानी से एक्सपोज़ हो सकता है।