Percona MongoDB Kubernetes ऑपरेटर का अवलोकन

MongoDB और Kubernetes एक बेहतरीन संयोजन है, विशेष रूप से जटिलता के संबंध में। फिर भी, Percona का MongoDB (PSMDB) NoSQL डेटाबेस के लिए अधिक लचीलापन प्रदान करता है, और यह उन उपकरणों के साथ भी आता है जो आज की उत्पादकता के लिए कुशल हैं; न केवल ऑन-प्रिमाइसेस बल्कि क्लाउड नेटिव के लिए भी उपलब्ध है।

कुबेरनेट्स की गोद लेने की दर लगातार बढ़ रही है। यह उचित है कि एक तकनीक के पास निम्न कार्य करने के लिए एक ऑपरेटर होना चाहिए:MongoDB वातावरण के लिए Percona Server आइटम का निर्माण, संशोधन और विलोपन। Percona MongoDB Kubernetes Operator में MongoDB उदाहरण के लिए एक सुसंगत Percona सर्वर को बनाए रखने के लिए आवश्यक k8s सेटिंग्स शामिल हैं। एक वैकल्पिक विकल्प के रूप में, आप इसकी तुलना https://github.com/kubedb/mongodb से कर सकते हैं लेकिन MongoDB के लिए KubeDB विशेष रूप से उत्पादन ग्रेड सिस्टम पर ऑफ़र करने के लिए बहुत सीमित विकल्प प्रदान करता है।

पेरकोना कुबेरनेट्स ऑपरेटर्स अपने कॉन्फ़िगरेशन का दावा करते हुए आधारित हैं और पीएसएमडीबी प्रतिकृति सेट के कॉन्फ़िगरेशन के लिए सर्वोत्तम प्रथाओं का पालन कर रहे हैं। सबसे महत्वपूर्ण बात यह है कि मोंगोडीबी के लिए ऑपरेटर स्वयं कई लाभ प्रदान करता है लेकिन समय की बचत, एक सुसंगत वातावरण सबसे महत्वपूर्ण है। इस ब्लॉग में, हम इस बात का अवलोकन करेंगे कि यह विशेष रूप से एक कंटेनरीकृत वातावरण में कैसे फायदेमंद है।

यह ऑपरेटर क्या पेशकश कर सकता है?

यह ऑपरेटर प्रतिकृति सेट का उपयोग करके PSMDB के लिए उपयोगी है। इसका मतलब है कि, आपके डेटाबेस डिज़ाइन आर्किटेक्चर को नीचे दिए गए आरेख के अनुरूप होना चाहिए

परकोना के डॉक्यूमेंटेशन डिजाइन ओवरव्यू से ली गई इमेज

वर्तमान में, इस ऑपरेटर के लिए उपलब्ध समर्थित प्लेटफॉर्म हैं:

OpenShift 3.11
OpenShift 4.5
Google Kubernetes Engine (GKE) 1.15 - 1.17
कुबेरनेट्स (EKS) 1.15 के लिए अमेज़न इलास्टिक कंटेनर सर्विस
मिनीक्यूब 1.10
VMWare Tanzu

अन्य कुबेरनेट्स प्लेटफॉर्म भी काम कर सकते हैं लेकिन उनका परीक्षण नहीं किया गया है।

संसाधन सीमाएं

आधिकारिक तौर पर समर्थित प्लेटफॉर्म चलाने वाले क्लस्टर में निम्नलिखित संसाधनों के साथ कम से कम तीन नोड होते हैं:

2GB RAM
पॉड्स प्रोविजनिंग के लिए प्रति नोड 2 CPU थ्रेड्स
निजी मात्रा के प्रावधान के लिए कम से कम 60GB उपलब्ध संग्रहण

सुरक्षा और/या प्रतिबंध प्रतिबंध

कुबेरनेट्स पॉड्स बनाते समय काम करता है, प्रत्येक पॉड का क्लस्टर के आंतरिक वर्चुअल नेटवर्क में एक आईपी एड्रेस होता है। पॉड्स बनाना या नष्ट करना दोनों गतिशील प्रक्रियाएं हैं, इसलिए पॉड्स के बीच संचार के लिए निर्दिष्ट विशिष्ट आईपी पते पर अपने पॉड्स को बांधने की अनुशंसा नहीं की जाती है। यह समस्याएँ पैदा कर सकता है क्योंकि क्लस्टर स्केलिंग, अनजाने में हुई गलतियों, डीसी आउटेज या आपदाओं, या आवधिक रखरखाव आदि के परिणामस्वरूप चीजें समय के साथ बदलती हैं। उस स्थिति में, ऑपरेटर आपको कुबेरनेट्स आंतरिक के माध्यम से MongoDB के लिए Percona सर्वर से कनेक्ट करने की सख्ती से अनुशंसा करता है। URI में DNS नाम (जैसे mongodb+srv://userAdmin:[email protected]-rs0..svc.cluster.local/admin?replicaSet=rs0&ssl=false)।

यह PSMDB Kubernetes Operator भी एफ़िनिटी/एंटी-एफ़िनिटी का उपयोग करता है जो उन बाधाओं को प्रदान करता है जिनके लिए आपके पॉड्स को चलाने के लिए शेड्यूल किया जा सकता है या एक विशिष्ट नोड पर शुरू किया जा सकता है। एफ़िनिटी उन योग्य पॉड्स को परिभाषित करती है जिन्हें नोड पर शेड्यूल किया जा सकता है जिसमें पहले से ही विशिष्ट लेबल वाले पॉड होते हैं। एंटी-एफ़िनिटी उन पॉड्स को परिभाषित करती है जो योग्य नहीं हैं। यह दृष्टिकोण यह सुनिश्चित करके लागत को कम करता है कि गहन डेटा एक्सचेंज के साथ कई पॉड एक ही उपलब्धता क्षेत्र या यहां तक कि एक ही नोड पर कब्जा कर लेते हैं या इसके विपरीत, उच्च उपलब्धता और संतुलन उद्देश्यों के लिए विभिन्न नोड्स या यहां तक कि विभिन्न उपलब्धता क्षेत्रों पर पॉड्स को फैलाते हैं। हालांकि ऑपरेटर आपको एफ़िनिटी/एंटी-एफ़िनिटी सेट करने के लिए प्रोत्साहित करता है, फिर भी मिनिक्यूब का उपयोग करते समय इसकी सीमाएँ हैं।

मिनीक्यूब का उपयोग करते समय, इसकी निम्नलिखित प्लेटफ़ॉर्म-विशिष्ट सीमाएं होती हैं। मिनिक्यूब अपनी स्थानीय प्रकृति के कारण मल्टी-नोड क्लस्टर कॉन्फ़िगरेशन का समर्थन नहीं करता है, जो ऑपरेटर की डिफ़ॉल्ट एफ़िनिटी आवश्यकताओं के साथ टकराव में है। इसे व्यवस्थित करने के लिए, मिनिक्यूब निर्देश पर MongoDB के लिए Percona सर्वर स्थापित करें में एक अतिरिक्त चरण शामिल है जो कम से कम तीन नोड्स होने की आवश्यकता को बंद कर देता है।

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

ट्रांज़िट में डेटा/आराम पर डेटा

PSMDB के साथ डेटा सुरक्षा के लिए, ऑपरेटर ट्रांज़िट के लिए TLS/SSL ऑफ़र करता है, फिर डेटा के रुकने पर एन्क्रिप्शन भी ऑफ़र करता है। ट्रांज़िट के लिए, आप जो विकल्प चुन सकते हैं, वह है सर्टिफिकेट-मैनेजर का उपयोग करना, या मैन्युअल रूप से अपना स्वयं का प्रमाणपत्र बनाना। बेशक, आप वैकल्पिक रूप से इस ऑपरेटर के लिए TLS के बिना PSMDB का उपयोग कर सकते हैं। TLS का उपयोग करने के संबंध में उनके दस्तावेज़ देखें।

आराम से डेटा के लिए, इसे अपने PSMDB Kubernetes ऑपरेटर के भीतर परिवर्तन की आवश्यकता होती है जब आप github शाखा को डाउनलोड करते हैं, फिर परिनियोजन/cr.yaml फ़ाइल पर परिवर्तन लागू करते हैं। इसे सक्षम करने के लिए, दस्तावेज़ीकरण द्वारा सुझाए गए अनुसार निम्न कार्य करें:

security.enableEncryption key को true (डिफ़ॉल्ट मान) पर सेट किया जाना चाहिए।
Security.encryptionCipherMode कुंजी को डिक्रिप्शन के लिए उचित सिफर मोड निर्दिष्ट करना चाहिए। मान निम्नलिखित दो प्रकारों में से एक हो सकता है:
- AES256-CBC (मोंगोडीबी के लिए ऑपरेटर और पेरकोना सर्वर के लिए डिफ़ॉल्ट एक)
- AES256-GCM

security.encryptionKeySecret should specify a secret object with the encryption key:

mongod:

  ...

  security:

    ...

    encryptionKeySecret: my-cluster-name-mongodb-encryption-key

एन्क्रिप्शन कुंजी सीक्रेट मौजूद नहीं होने पर अपने आप बन जाएगा। यदि आप इसे स्वयं बनाना चाहते हैं, तो ध्यान रखें कि कुंजी 32 वर्णों वाली स्ट्रिंग होनी चाहिए, जो बेस 64 में एन्कोडेड होनी चाहिए।

संवेदनशील जानकारी संग्रहीत करना

PSMDB Kubernetes Operator संवेदनशील जानकारी को संग्रहीत और प्रबंधित करने के लिए Kubernetes Secrets का उपयोग करता है। Kubernetes Secrets आपको संवेदनशील जानकारी, जैसे पासवर्ड, OAuth टोकन और ssh कुंजियाँ संग्रहीत और प्रबंधित करने देता है। गोपनीय जानकारी को पॉड परिभाषा में या कंटेनर छवि में शब्दशः डालने की तुलना में गोपनीय जानकारी को संग्रहीत करना अधिक सुरक्षित और लचीला है।

इस ऑपरेटर के लिए, आपके पॉड्स के लिए जेनरेट किए गए उपयोगकर्ता और पासवर्ड संग्रहीत किए जाते हैं और Kubectl get secrets -o yaml set in your Deploy/cr.yaml का उपयोग करके प्राप्त किया जा सकता है। ।

इस ब्लॉग के लिए, मेरा उदाहरण सेटअप डीकोड किए गए बेस64 परिणाम के साथ निम्नलिखित प्राप्त करता है।

 kubectl get secrets mongodb-cluster-s9s-secrets -o yaml | egrep '^\s+MONGODB.*'|cut -d ':' -f2 | xargs -I% sh -c "echo % | base64 -d; echo "

WrDry6bexkCPOY5iQ

backup

gAWBKkmIQsovnImuKyl

clusterAdmin

qHskMMseNqU8DGbo4We

clusterMonitor

TQBEV7rtE15quFl5

userAdmin

बैकअप के लिए प्रत्येक प्रविष्टि, क्लस्टर उपयोगकर्ता, क्लस्टर मॉनिटर उपयोगकर्ता, और प्रशासनिक उपयोग के लिए उपयोगकर्ता उपरोक्त परिणाम के आधार पर दिखाता है।

एक और बात यह भी है कि, PSMDB Kubernetes Operator, Kubernetes Secrets के माध्यम से AWS S3 एक्सेस और गुप्त कुंजियों को भी स्टोर करता है।

बैकअप

यह ऑपरेटर बैकअप का समर्थन करता है जो एक बहुत अच्छी विशेषता है। यह ऑन-डिमांड (मैनुअल) बैकअप और अनुसूचित बैकअप का समर्थन करता है और मोंगोडीबी के लिए बैकअप टूल पेरकोना बैकअप का उपयोग करता है। ध्यान दें कि बैकअप केवल AWS S3 या किसी S3-संगत संग्रहण पर संग्रहीत होते हैं।

निर्धारित बैकअप को परिनियोजन/cr.yaml फ़ाइल के माध्यम से परिभाषित किया जा सकता है, जबकि मैन्युअल बैकअप लेना जब भी आवश्यक हो, कभी भी किया जा सकता है। S3 एक्सेस और गुप्त कुंजियों के लिए, इसे फ़ाइल परिनियोजन/बैकअप-s3.yaml फ़ाइल में परिभाषित किया जाएगा और जैसा कि हमने पहले उल्लेख किया है, निम्न जानकारी संग्रहीत करने के लिए Kubernetes Secrets का उपयोग करता है।

इस पीएसएमडीबी कुबेरनेट्स ऑपरेटर के लिए समर्थित सभी कार्रवाइयां निम्नलिखित हैं:

शेड्यूल बैकअप बनाना
ऑन-डिमांड बैकअप बनाना
पहले से सहेजे गए बैकअप से क्लस्टर को पुनर्स्थापित करें
अनावश्यक बैकअप हटाएं

मिनीक्यूब के साथ PSMDB Kubernetes ऑपरेटर का उपयोग करना

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

इससे पहले कि हम चरणों के साथ आगे बढ़ें, ध्यान रखें कि जैसा कि ऊपर उल्लेख किया गया है, मिनिक्यूब के साथ एक ज्ञात सीमा रही है क्योंकि यह मल्टी-नोड क्लस्टर कॉन्फ़िगरेशन का समर्थन नहीं करता है जो ऑपरेटर की डिफ़ॉल्ट आत्मीयता आवश्यकताओं के साथ टकराव में है। हम नीचे दिए गए चरणों में इसका उल्लेख करेंगे कि इसे कैसे संभालना है।

इस ब्लॉग के लिए, होस्ट ओएस जहां हमारा मिनीक्यूब स्थापित किया जाएगा, वह उबंटू 18.04 (बायोनिक बीवर) पर है।

आइए मिनिक्यूब स्थापित करें

$ curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb

$ sudo dpkg -i minikube_latest_amd64.deb

वैकल्पिक रूप से, यदि आप विभिन्न Linux सिस्टम पर हैं तो आप यहां दिए गए चरणों का पालन कर सकते हैं।

हमारे Kubernetes संकुल को प्रमाणित करने और रिपॉजिटरी सेटअप करने के लिए आवश्यक कुंजी जोड़ें

$ curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

$ cat <<eof > /etc/apt/sources.list.d/kubernetes.list

deb https://apt.kubernetes.io/ kubernetes-xenial main

deb https://apt.kubernetes.io/ kubernetes-yakkety main

eof

आइए अब आवश्यक पैकेज स्थापित करें

$ sudo apt-get update

$ sudo apt-get install kubelet kubeadm kubectl

मेमोरी, सीपीयू की संख्या और सीआईडीआर को परिभाषित करते हुए मिनिक्यूब को प्रारंभ करें जिसके लिए मेरे नोड्स असाइन किए जाएंगे,

$ minikube start --memory=4096 --cpus=3 --extra-config=kubeadm.pod-network-cidr=192.168.0.0/16

उदाहरण के परिणाम इस तरह दिखाते हैं,

minikube v1.14.2 on Ubuntu 18.04

Automatically selected the docker driver

docker is currently using the aufs storage driver, consider switching to overlay2 for better performance

Starting control plane node minikube in cluster minikube

Creating docker container (CPUs=3, Memory=4096MB) ...

Preparing Kubernetes v1.19.2 on Docker 19.03.8 ...

kubeadm.pod-network-cidr=192.168.0.0/16

 > kubeadm.sha256: 65 B / 65 B [--------------------------] 100.00% ? p/s 0s

 > kubectl.sha256: 65 B / 65 B [--------------------------] 100.00% ? p/s 0s

 > kubelet.sha256: 65 B / 65 B [--------------------------] 100.00% ? p/s 0s

 > kubeadm: 37.30 MiB / 37.30 MiB [---------------] 100.00% 1.46 MiB p/s 26s

 > kubectl: 41.01 MiB / 41.01 MiB [---------------] 100.00% 1.37 MiB p/s 30s

 > kubelet: 104.88 MiB / 104.88 MiB [------------] 100.00% 1.53 MiB p/s 1m9s

Verifying Kubernetes components...

Enabled addons: default-storageclass, storage-provisioner

Done! kubectl is now configured to use "minikube" by default

जैसा कि आपने देखा, यह आपके नोड्स या पॉड्स को प्रबंधित और प्रबंधित करने के लिए उपयोगिता उपकरण भी स्थापित करता है।

अब, निम्न कमांड चलाकर नोड्स और पॉड्स की जांच करें,

$ kubectl get pods -A

NAMESPACE     NAME                               READY   STATUS    RESTARTS   AGE

kube-system   coredns-f9fd979d6-gwngd            1/1     Running   0          45s

kube-system   etcd-minikube                      0/1     Running   0          53s

kube-system   kube-apiserver-minikube            1/1     Running   0          53s

kube-system   kube-controller-manager-minikube   0/1     Running   0          53s

kube-system   kube-proxy-m25hm                   1/1     Running   0          45s

kube-system   kube-scheduler-minikube            0/1     Running   0          53s

kube-system   storage-provisioner                1/1     Running   1          57s

$ kubectl get nodes -owide

NAME       STATUS   ROLES    AGE    VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE           KERNEL-VERSION      CONTAINER-RUNTIME

minikube   Ready    master   2d4h   v1.19.2   192.168.49.2   <none>        Ubuntu 20.04 LTS   4.15.0-20-generic   docker://19.3.8

अब, PSMDB Kubernetes Operator डाउनलोड करें,

$ git clone -b v1.5.0 https://github.com/percona/percona-server-mongodb-operator

$ cd percona-server-mongodb-operator

अब हम ऑपरेटर को परिनियोजित करने के लिए तैयार हैं,

$ kubectl apply -f deploy/bundle.yaml

जैसा कि पहले उल्लेख किया गया है, चीजों को अपेक्षित रूप से चलाने के लिए मिनिक्यूब की सीमाओं में समायोजन की आवश्यकता होती है। आइए निम्न कार्य करें:

आपकी वर्तमान हार्डवेयर क्षमता के आधार पर, आप दस्तावेज़ द्वारा सुझाए गए अनुसार निम्नलिखित को बदल सकते हैं। चूंकि मिनीक्यूब स्थानीय रूप से चलता है, इसलिए सीमित संसाधनों के साथ स्थानीय संस्थापन के लिए ऑपरेटर को अनुकूलित करने के लिए डिफ़ॉल्ट परिनियोजन/cr.yaml फ़ाइल को संपादित किया जाना चाहिए। प्रतिकृति अनुभाग में निम्नलिखित कुंजियों को बदलें:
- टिप्पणी संसाधन।
- एफ़िनिटी सेट करें
साथ ही, allowUnsafeConfigurations कुंजी को सही पर स्विच करें (यह विकल्प क्लस्टर कॉन्फ़िगरेशन पर ऑपरेटर के नियंत्रण को बंद कर देता है, जिससे MongoDB के लिए Percona सर्वर को एक-नोड क्लस्टर के रूप में तैनात करना संभव हो जाता है)।

अब, हम डिप्लॉय/cr.yaml फ़ाइल में किए गए परिवर्तनों को लागू करने के लिए तैयार हैं।

$ kubectl apply -f deploy/cr.yaml

इस बिंदु पर, आप पॉड्स की स्थिति की जांच करने में सक्षम हो सकते हैं और आप नीचे की तरह निम्न प्रगति देखेंगे,

$ kubectl get pods

NAME                                              READY   STATUS              RESTARTS   AGE

percona-server-mongodb-operator-588db759d-qjv29   0/1     ContainerCreating   0          15s



$ kubectl get pods

NAME                                              READY   STATUS     RESTARTS   AGE

mongodb-cluster-s9s-rs0-0                         0/2     Init:0/1   0          4s

percona-server-mongodb-operator-588db759d-qjv29   1/1     Running    0          34s



$ kubectl get pods

NAME                                              READY   STATUS            RESTARTS   AGE

mongodb-cluster-s9s-rs0-0                         0/2     PodInitializing   0          119s

percona-server-mongodb-operator-588db759d-qjv29   1/1     Running           0          2m29s



kubectl get pods

NAME                                              READY   STATUS            RESTARTS   AGE

mongodb-cluster-s9s-rs0-0                         0/2     PodInitializing   0          2m1s

percona-server-mongodb-operator-588db759d-qjv29   1/1     Running           0          2m31s



kubectl get pods

NAME                                              READY   STATUS    RESTARTS   AGE

mongodb-cluster-s9s-rs0-0                         2/2     Running   0          33m

mongodb-cluster-s9s-rs0-1                         2/2     Running   1          31m

mongodb-cluster-s9s-rs0-2                         2/2     Running   0          30m

percona-server-mongodb-operator-588db759d-qjv29   1/1     Running   0          33m

अब जबकि हम लगभग वहाँ हैं। हम ऑपरेटर द्वारा उत्पन्न रहस्य प्राप्त करेंगे ताकि हम बनाए गए PSMDB पॉड से जुड़ सकें। ऐसा करने के लिए, आपको पहले गुप्त वस्तुओं को सूचीबद्ध करना होगा, फिर yaml का मान प्राप्त करना होगा ताकि आप उपयोगकर्ता/पासवर्ड संयोजन प्राप्त कर सकें। दूसरी ओर, आप नीचे दिए गए संयुक्त कमांड का उपयोग उपयोगकर्ता नाम:पासवर्ड प्रारूप के साथ कर सकते हैं। नीचे दिया गया उदाहरण देखें,

$ kubectl get secrets

NAME                                          TYPE                                  DATA   AGE

default-token-c8frr                           kubernetes.io/service-account-token   3      2d4h

internal-mongodb-cluster-s9s-users            Opaque                                8      2d4h

mongodb-cluster-s9s-mongodb-encryption-key    Opaque                                1      2d4h

mongodb-cluster-s9s-mongodb-keyfile           Opaque                                1      2d4h

mongodb-cluster-s9s-secrets                   Opaque                                8      2d4h

percona-server-mongodb-operator-token-rbzbc   kubernetes.io/service-account-token   3      2d4h



$ kubectl get secrets mongodb-cluster-s9s-secrets -o yaml | egrep '^\s+MONGODB.*'|cut -d ':' -f2 | xargs -I% sh -c "echo % | base64 -d; echo" |sed 'N; s/\(.*\)\n\(.*\)/

\2:\1/'

backup:WrDry6bexkCPOY5iQ

clusterAdmin:gAWBKkmIQsovnImuKyl

clusterMonitor:qHskMMseNqU8DGbo4We

userAdmin:TQBEV7rtE15quFl5

अब, आप उपयोगकर्ता नाम:पासवर्ड प्रारूप को आधार बना सकते हैं और इसे कहीं सुरक्षित रूप से सहेज सकते हैं।

चूंकि हम MongoDB नोड्स के लिए Percona सर्वर से सीधे कनेक्ट नहीं हो सकते हैं, इसलिए हमें एक नया पॉड बनाने की आवश्यकता है जिसमें mongodb क्लाइंट हो,

$ kubectl run -i --rm --tty percona-client --image=percona/percona-server-mongodb:4.2.8-8 --restart=Never -- bash -il

अंत में, अब हम अपने PSMDB नोड्स से जुड़ने के लिए तैयार हैं,

bash-4.2$ mongo "mongodb+srv://userAdmin:[email protected]/admin?replicaSet=rs0&ssl=false"

वैकल्पिक रूप से, आप अलग-अलग नोड्स से जुड़ सकते हैं और इसके स्वास्थ्य की जांच कर सकते हैं। उदाहरण के लिए,

bash-4.2$ mongo --host "mongodb://clusterAdmin:[email protected]:27017/?authSource=admin&ssl=false"

Percona Server for MongoDB shell version v4.2.8-8

connecting to: mongodb://mongodb-cluster-s9s-rs0-2.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017/?authSource=admin&compressors=disabled&gssapiServiceName=mongodb&ssl=false

Implicit session: session { "id" : UUID("9b29b9b3-4f82-438d-9857-eff145be0ee6") }

Percona Server for MongoDB server version: v4.2.8-8

Welcome to the Percona Server for MongoDB shell.

For interactive help, type "help".

For more comprehensive documentation, see

        https://www.percona.com/doc/percona-server-for-mongodb

Questions? Try the support group

        https://www.percona.com/forums/questions-discussions/percona-server-for-mongodb

2020-11-09T07:41:59.172+0000 I  STORAGE  [main] In File::open(), ::open for '/home/mongodb/.mongorc.js' failed with No such file or directory

Server has startup warnings:

2020-11-09T06:41:16.838+0000 I  CONTROL  [initandlisten] ** WARNING: While invalid X509 certificates may be used to

2020-11-09T06:41:16.838+0000 I  CONTROL  [initandlisten] **          connect to this server, they will not be considered

2020-11-09T06:41:16.838+0000 I  CONTROL  [initandlisten] **          permissible for authentication.

2020-11-09T06:41:16.838+0000 I  CONTROL  [initandlisten]

rs0:SECONDARY> rs.status()

{

        "set" : "rs0",

        "date" : ISODate("2020-11-09T07:42:04.984Z"),

        "myState" : 2,

        "term" : NumberLong(5),

        "syncingTo" : "mongodb-cluster-s9s-rs0-0.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

        "syncSourceHost" : "mongodb-cluster-s9s-rs0-0.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

        "syncSourceId" : 0,

        "heartbeatIntervalMillis" : NumberLong(2000),

        "majorityVoteCount" : 2,

        "writeMajorityCount" : 2,

        "optimes" : {

                "lastCommittedOpTime" : {

                        "ts" : Timestamp(1604907723, 4),

                        "t" : NumberLong(5)

                },

                "lastCommittedWallTime" : ISODate("2020-11-09T07:42:03.395Z"),

                "readConcernMajorityOpTime" : {

                        "ts" : Timestamp(1604907723, 4),

                        "t" : NumberLong(5)

                },

                "readConcernMajorityWallTime" : ISODate("2020-11-09T07:42:03.395Z"),

                "appliedOpTime" : {

                        "ts" : Timestamp(1604907723, 4),

                        "t" : NumberLong(5)

                },

                "durableOpTime" : {

                        "ts" : Timestamp(1604907723, 4),

                        "t" : NumberLong(5)

                },

                "lastAppliedWallTime" : ISODate("2020-11-09T07:42:03.395Z"),

                "lastDurableWallTime" : ISODate("2020-11-09T07:42:03.395Z")

        },

        "lastStableRecoveryTimestamp" : Timestamp(1604907678, 3),

        "lastStableCheckpointTimestamp" : Timestamp(1604907678, 3),

        "members" : [

                {

                        "_id" : 0,

                        "name" : "mongodb-cluster-s9s-rs0-0.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

                        "health" : 1,

                        "state" : 1,

                        "stateStr" : "PRIMARY",

                        "uptime" : 3632,

                        "optime" : {

                                "ts" : Timestamp(1604907723, 4),

                                "t" : NumberLong(5)

                        },

                        "optimeDurable" : {

                                "ts" : Timestamp(1604907723, 4),

                                "t" : NumberLong(5)

                        },

                       "optimeDate" : ISODate("2020-11-09T07:42:03Z"),

                        "optimeDurableDate" : ISODate("2020-11-09T07:42:03Z"),

                        "lastHeartbeat" : ISODate("2020-11-09T07:42:04.246Z"),

                        "lastHeartbeatRecv" : ISODate("2020-11-09T07:42:03.162Z"),

                        "pingMs" : NumberLong(0),

                        "lastHeartbeatMessage" : "",

                        "syncingTo" : "",

                        "syncSourceHost" : "",

                        "syncSourceId" : -1,

                        "infoMessage" : "",

                        "electionTime" : Timestamp(1604904092, 1),

                        "electionDate" : ISODate("2020-11-09T06:41:32Z"),

                        "configVersion" : 3

                },

                {

                        "_id" : 1,

                        "name" : "mongodb-cluster-s9s-rs0-1.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

                        "health" : 1,

                        "state" : 2,

                        "stateStr" : "SECONDARY",

                        "uptime" : 3632,

                        "optime" : {

                                "ts" : Timestamp(1604907723, 4),

                                "t" : NumberLong(5)

                        },

                        "optimeDurable" : {

                                "ts" : Timestamp(1604907723, 4),

                                "t" : NumberLong(5)

                        },

                        "optimeDate" : ISODate("2020-11-09T07:42:03Z"),

                        "optimeDurableDate" : ISODate("2020-11-09T07:42:03Z"),

                        "lastHeartbeat" : ISODate("2020-11-09T07:42:04.244Z"),

                        "lastHeartbeatRecv" : ISODate("2020-11-09T07:42:04.752Z"),

                        "pingMs" : NumberLong(0),

                        "lastHeartbeatMessage" : "",

                        "syncingTo" : "mongodb-cluster-s9s-rs0-2.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

                        "syncSourceHost" : "mongodb-cluster-s9s-rs0-2.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

                        "syncSourceId" : 2,

                        "infoMessage" : "",

                        "configVersion" : 3

                },

                {

                        "_id" : 2,

                        "name" : "mongodb-cluster-s9s-rs0-2.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

                        "health" : 1,

                        "state" : 2,

                        "stateStr" : "SECONDARY",

                        "uptime" : 3651,

                        "optime" : {

                                "ts" : Timestamp(1604907723, 4),

                                "t" : NumberLong(5)

                        },

                        "optimeDate" : ISODate("2020-11-09T07:42:03Z"),

                        "syncingTo" : "mongodb-cluster-s9s-rs0-0.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

                        "syncSourceHost" : "mongodb-cluster-s9s-rs0-0.mongodb-cluster-s9s-rs0.default.svc.cluster.local:27017",

                        "syncSourceId" : 0,

                        "infoMessage" : "",

                        "configVersion" : 3,

                        "self" : true,

                        "lastHeartbeatMessage" : ""

                }

        ],

        "ok" : 1,

        "$clusterTime" : {

                "clusterTime" : Timestamp(1604907723, 4),

                "signature" : {

                        "hash" : BinData(0,"HYC0i49c+kYdC9M8KMHgBdQW1ac="),

                        "keyId" : NumberLong("6892206918371115011")

                }

        },

        "operationTime" : Timestamp(1604907723, 4)

}

चूंकि ऑपरेटर क्लस्टर की स्थिरता का प्रबंधन करता है, जब भी कोई विफलता या मान लें कि एक पॉड हटा दिया गया है। ऑपरेटर स्वचालित रूप से एक नया आरंभ करेगा। उदाहरण के लिए,

$ kubectl get po

NAME                                              READY   STATUS    RESTARTS   AGE

mongodb-cluster-s9s-rs0-0                         2/2     Running   0          2d5h

mongodb-cluster-s9s-rs0-1                         2/2     Running   0          2d5h

mongodb-cluster-s9s-rs0-2                         2/2     Running   0          2d5h

percona-client                                    1/1     Running   0          3m7s

percona-server-mongodb-operator-588db759d-qjv29   1/1     Running   0          2d5h

$ kubectl delete po mongodb-cluster-s9s-rs0-1

pod "mongodb-cluster-s9s-rs0-1" deleted

$ kubectl get po

NAME                                              READY   STATUS     RESTARTS   AGE

mongodb-cluster-s9s-rs0-0                         2/2     Running    0          2d5h

mongodb-cluster-s9s-rs0-1                         0/2     Init:0/1   0          3s

mongodb-cluster-s9s-rs0-2                         2/2     Running    0          2d5h

percona-client                                    1/1     Running    0          3m29s

percona-server-mongodb-operator-588db759d-qjv29   1/1     Running    0          2d5h

$ kubectl get po

NAME                                              READY   STATUS            RESTARTS   AGE

mongodb-cluster-s9s-rs0-0                         2/2     Running           0          2d5h

mongodb-cluster-s9s-rs0-1                         0/2     PodInitializing   0          10s

mongodb-cluster-s9s-rs0-2                         2/2     Running           0          2d5h

percona-client                                    1/1     Running           0          3m36s

percona-server-mongodb-operator-588db759d-qjv29   1/1     Running           0          2d5h

$ kubectl get po

NAME                                              READY   STATUS    RESTARTS   AGE

mongodb-cluster-s9s-rs0-0                         2/2     Running   0          2d5h

mongodb-cluster-s9s-rs0-1                         2/2     Running   0          26s

mongodb-cluster-s9s-rs0-2                         2/2     Running   0          2d5h

percona-client                                    1/1     Running   0          3m52s

percona-server-mongodb-operator-588db759d-qjv29   1/1     Running   0          2d5h

अब जबकि हम सब तैयार हैं। बेशक, आपको बंदरगाह का पर्दाफाश करने की आवश्यकता हो सकती है ताकि आपको तैनाती/cr.yaml में समायोजन से निपटना पड़े। इससे निपटने के लिए आप यहां देख सकते हैं।

निष्कर्ष

PSMDB के लिए Percona Kubernetes ऑपरेटर विशेष रूप से MongoDB सेटअप के लिए आपके Percona सर्वर के लिए कंटेनरीकृत वातावरण के लिए आपका संपूर्ण समाधान हो सकता है। यह लगभग एक पूर्ण समाधान है क्योंकि इसमें आपके प्रतिकृति सेट के लिए अंतर्निहित अतिरेक है, फिर भी ऑपरेटर बैकअप, मापनीयता, उच्च-उपलब्धता और सुरक्षा का समर्थन करता है।