ग्लस्टरएफएस और मेटलएलबी के साथ नंगे धातु पर कुबेरनेट्स हा क्लस्टर को कॉन्फ़िगर करें। भाग 2/3

भाग 1/3 यहाँ
भाग 3/3 यहाँ

नमस्कार और वापस स्वागत है! नंगे धातु पर कुबेरनेट क्लस्टर बनाने के लेख का यह दूसरा भाग है। पहले, हमने Kubernetes HA क्लस्टर को बाहरी वॉर्ड, एक मास्टर-मास्टर स्कीम और लोड बैलेंसिंग का उपयोग करके कॉन्फ़िगर किया था। खैर, अब क्लस्टर को अधिक उपयोगी बनाने और काम करने की स्थिति में जितना संभव हो सके, इसके लिए एक अतिरिक्त वातावरण और उपयोगिताओं को स्थापित करने का समय है।

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

1. एक आंतरिक लोड बैलेंसर के रूप में मेटलएलबी सेट करें।

सीधे दस्तावेज़ पृष्ठ से MetalLB के बारे में कुछ शब्द:

MetalLB मानक रूटिंग प्रोटोकॉल के साथ कुबेरनेट्स नंगे धातु समूहों के लिए एक लोड बैलेंसर कार्यान्वयन है।

कुबेरनेट्स नंगे धातु के लिए नेटवर्क लोड बैलेंसर्स ( सेवा प्रकार लोडबेलर ) के कार्यान्वयन की पेशकश नहीं करते हैं। Kubernetes के साथ आने वाले सभी नेटवर्क LB कार्यान्वयन विकल्प मिडलवेयर हैं, और यह विभिन्न IaaS प्लेटफार्मों (GCP, AWS, Azure, आदि) तक पहुंचता है। यदि आप IaaS (GCP, AWS, Azure, इत्यादि) द्वारा समर्थित प्लेटफॉर्म पर काम नहीं कर रहे हैं, तो LoadBalancer निर्माण पर अनिश्चित काल के लिए "स्टैंडबाय" स्थिति में रहेगा।

बीएम सर्वर ऑपरेटरों के पास उनके क्लस्टर, NodePort और externalIPs सेवाओं में उपयोगकर्ता यातायात में प्रवेश करने के लिए दो कम प्रभावी उपकरण हैं। इन दोनों विकल्पों में उत्पादन में महत्वपूर्ण कमियां हैं, जो कुबेरनेट्स पारिस्थितिकी तंत्र में बीएम समूहों को द्वितीय श्रेणी के नागरिकों में बदल देता है।

मेटलएलबी एक नेटवर्क एलबी कार्यान्वयन की पेशकश करके इस असंतुलन को ठीक करना चाहता है जो मानक नेटवर्क उपकरण के साथ एकीकृत होता है, इसलिए बीएम क्लस्टर पर बाहरी सेवाएं भी अधिकतम गति पर "बस काम" करती हैं।

इस प्रकार, इस उपकरण का उपयोग करते हुए, हम एक लोड बैलेंसर का उपयोग करके कुबेरनेट्स क्लस्टर में सेवाएं लॉन्च करते हैं, जिसके लिए मेटलबीटी टीम को बहुत धन्यवाद। सेटअप प्रक्रिया वास्तव में सरल और सीधी है।

इससे पहले उदाहरण में, हमने अपने क्लस्टर की जरूरतों के लिए 192.168.0.0/24 सबनेट का चयन किया। अब भविष्य के लोड बैलेंसर के लिए इस सबनेट में से कुछ को लें।

हम कॉन्फ़िगर किए गए kubectl उपयोगिता के साथ मशीन सिस्टम में प्रवेश करते हैं और चलाते हैं:

control# kubectl apply -f https://raw.githubusercontent.com/google/metallb/v0.7.3/manifests/metallb.yaml 

यह metallb-system में metallb-system को क्लस्टर में तैनात करेगा। सुनिश्चित करें कि सभी MetalLB घटक ठीक से काम कर रहे हैं:

 control# kubectl get pod --namespace=metallb-system NAME READY STATUS RESTARTS AGE controller-7cc9c87cfb-ctg7p 1/1 Running 0 5d3h speaker-82qb5 1/1 Running 0 5d3h speaker-h5jw7 1/1 Running 0 5d3h speaker-r2fcg 1/1 Running 0 5d3h 

अब कॉन्फ़िगर करें का उपयोग करके मेटलएलबी को कॉन्फ़िगर करें। इस उदाहरण में, हम लेयर 2 अनुकूलन का उपयोग कर रहे हैं। अन्य अनुकूलन विकल्पों के बारे में जानकारी के लिए, मेटलएलबी प्रलेखन देखें।

हमारे क्लस्टर के सबनेट के चयनित IP रेंज के अंदर किसी भी डायरेक्टरी में metallb-config.yaml फ़ाइल बनाएँ:

 control# vi metallb-config.yaml apiVersion: v1 kind: ConfigMap metadata: namespace: metallb-system name: config data: config: | address-pools: - name: default protocol: layer2 addresses: - 192.168.0.240-192.168.0.250 

और इस सेटिंग को लागू करें:

 control# kubectl apply -f metallb-config.yaml 

यदि आवश्यक हो तो बाद में कॉन्फ़िगरमैप को जांचें और संशोधित करें:

 control# kubectl describe configmaps -n metallb-system control# kubectl edit configmap config -n metallb-system 

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

 control# vi nginx-deployment.yaml apiVersion: apps/v1 kind: Deployment metadata: name: nginx-deployment spec: selector: matchLabels: app: nginx replicas: 3 template: metadata: labels: app: nginx spec: containers: - name: nginx image: nginx:latest ports: - containerPort: 80 control# vi nginx-service.yaml apiVersion: v1 kind: Service metadata: name: nginx spec: type: LoadBalancer selector: app: nginx ports: - port: 80 name: http 

फिर एक परीक्षण तैनाती और Nginx सेवा बनाएँ:

 control# kubectl apply -f nginx-deployment.yaml control# kubectl apply -f nginx-service.yaml 

और अब - परिणाम की जाँच करें:

 control# kubectl get po NAME READY STATUS RESTARTS AGE nginx-deployment-6574bd76c-fxgxr 1/1 Running 0 19s nginx-deployment-6574bd76c-rp857 1/1 Running 0 19s nginx-deployment-6574bd76c-wgt9n 1/1 Running 0 19s control# kubectl get svc NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE nginx LoadBalancer 10.100.226.110 192.168.0.240 80:31604/TCP 107s 

3 Nginx पॉड्स बनाए, जैसा कि हमने पहले तैनाती में संकेत दिया था। Nginx सेवा चक्रीय संतुलन योजना के अनुसार इन सभी पॉड्स पर यातायात को निर्देशित करेगी। और आप हमारे मेटलएलबी लोड बैलेंसर से प्राप्त बाहरी आईपी भी देख सकते हैं।

अब IP एड्रेस 192.168.0.240 तक रोल करने का प्रयास करें और आपको Nginx index.html पेज दिखाई देगा। परीक्षण परिनियोजन और Nginx सेवा को निकालने के लिए याद रखें।

 control# kubectl delete svc nginx service "nginx" deleted control# kubectl delete deployment nginx-deployment deployment.extensions "nginx-deployment" deleted 

खैर, यह सब MetalLB के साथ है, चलो आगे बढ़ते हैं - हम Kubernetes वॉल्यूम के लिए GlusterFS को कॉन्फ़िगर करते हैं।

2. काम करने वाले नोड्स पर हेकेटी के साथ ग्लस्टरफ़ोर्स को कॉन्फ़िगर करना।

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

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

अब हमारे पास एक नया आसान हेकेटी उपकरण है।

हेकेटी प्रलेखन से कुछ शब्द:

GlusterFS के लिए प्रतिष्ठित वॉल्यूम प्रबंधन संरचना।

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

यह अच्छा लगता है, और इसके अलावा, यह टूल हमारे वीएम क्लस्टर को कुबेरनेट्स के बड़े क्लाउड क्लस्टर के करीब लाएगा। अंत में, आप PersistentVolumeClaims बनाने में सक्षम होंगे, जो स्वचालित रूप से उत्पन्न होंगे, और बहुत कुछ।

आप GlusterFS को कॉन्फ़िगर करने के लिए अतिरिक्त सिस्टम हार्ड ड्राइव ले सकते हैं या बस कुछ डमी ब्लॉक डिवाइस बना सकते हैं। इस उदाहरण में, मैं दूसरी विधि का उपयोग करूंगा।

सभी तीन काम करने वाले नोड्स पर डमी ब्लॉक डिवाइस बनाएं:

 worker1-3# dd if=/dev/zero of=/home/gluster/image bs=1M count=10000 

आपको लगभग 10 जीबी की एक फाइल मिलेगी। फिर लोसेटअप का उपयोग करें - इसे इन नोड्स में जोड़ने के लिए, लूपबैक डिवाइस के रूप में:

 worker1-3# losetup /dev/loop0 /home/gluster/image 

कृपया ध्यान दें: यदि आपके पास पहले से ही किसी प्रकार का लूपबैक डिवाइस 0 है, तो आपको कोई अन्य नंबर चुनने की आवश्यकता होगी।

मैंने समय लिया और पता लगाया कि हेकेती ठीक से काम क्यों नहीं करना चाहती है। इसलिए, भविष्य के कॉन्फ़िगरेशन में किसी भी समस्या को रोकने के लिए, पहले सुनिश्चित करें कि हमने dm_thin_pool कर्नेल मॉड्यूल लोड किया है और सभी कामकाजी नोड पर glusterfs-client पैकेज स्थापित किया है।

 worker1-3# modprobe dm_thin_pool worker1-3# apt-get update && apt-get -y install glusterfs-client 

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

 worker1-3# vi /etc/systemd/system/loop_gluster.service [Unit] Description=Create the loopback device for GlusterFS DefaultDependencies=false Before=local-fs.target After=systemd-udev-settle.service Requires=systemd-udev-settle.service [Service] Type=oneshot ExecStart=/bin/bash -c "modprobe dm_thin_pool && [ -b /dev/loop0 ] || losetup /dev/loop0 /home/gluster/image" [Install] WantedBy=local-fs.target 

और इसे चालू करें:

 worker1-3# systemctl enable /etc/systemd/system/loop_gluster.service Created symlink /etc/systemd/system/local-fs.target.wants/loop_gluster.service → /etc/systemd/system/loop_gluster.service. 

तैयारी का काम पूरा हो गया है, और हम अपने क्लस्टर में GlusterFS और Heketi को तैनात करने के लिए तैयार हैं। इसके लिए, मैं इस शांत गाइड का उपयोग करूंगा। अधिकांश कमांड बाहरी नियंत्रण कंप्यूटर से लॉन्च किए जाते हैं, और क्लस्टर के भीतर किसी भी मास्टर नोड से बहुत छोटे कमांड लॉन्च किए जाते हैं।

सबसे पहले, रिपॉजिटरी को कॉपी करें और DaemonSet GlusterFS बनाएं:

 control# git clone https://github.com/heketi/heketi control# cd heketi/extras/kubernetes control# kubectl create -f glusterfs-daemonset.json 

अब हम GlusterFS के लिए हमारे तीन काम करने वाले नोड्स को चिह्नित करते हैं; उन्हें लेबल करने के बाद, GlusterFS पॉड्स बनाए जाएंगे:

 control# kubectl label node worker1 storagenode=glusterfs control# kubectl label node worker2 storagenode=glusterfs control# kubectl label node worker3 storagenode=glusterfs control# kubectl get pod NAME READY STATUS RESTARTS AGE glusterfs-5dtdj 1/1 Running 0 1m6s glusterfs-hzdll 1/1 Running 0 1m9s glusterfs-p8r59 1/1 Running 0 2m1s 

अब एक हेकेटी सेवा खाता बनाएँ:

 control# kubectl create -f heketi-service-account.json 

हम इस सेवा खाते के लिए चमकदार फली का प्रबंधन करने की क्षमता प्रदान करते हैं। ऐसा करने के लिए, हमारे नए बनाए गए सेवा खाते के लिए आवश्यक क्लस्टर फ़ंक्शन बनाएँ:

 control# kubectl create clusterrolebinding heketi-gluster-admin --clusterrole=edit --serviceaccount=default:heketi-service-account 

अब एक कुबेरनेट गुप्त कुंजी बनाते हैं जो हमारे हेकेटी उदाहरण के विन्यास को अवरुद्ध करता है:

 control# kubectl create secret generic heketi-config-secret --from-file=./heketi.json 

हेकेती के तहत पहला स्रोत बनाएं, जिसे हम पहले सेटअप संचालन के लिए उपयोग करते हैं और बाद में हटाते हैं:

 control# kubectl create -f heketi-bootstrap.json service "deploy-heketi" created deployment "deploy-heketi" created control# kubectl get pod NAME READY STATUS RESTARTS AGE deploy-heketi-1211581626-2jotm 1/1 Running 0 2m glusterfs-5dtdj 1/1 Running 0 6m6s glusterfs-hzdll 1/1 Running 0 6m9s glusterfs-p8r59 1/1 Running 0 7m1s 

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

सबसे पहले, हेकेटी-क्लाइंट उपयोगिता डाउनलोड करें और इसे बिन सिस्टम फ़ोल्डर में कॉपी करें:

 master1# wget https://github.com/heketi/heketi/releases/download/v8.0.0/heketi-client-v8.0.0.linux.amd64.tar.gz master1# tar -xzvf ./heketi-client-v8.0.0.linux.amd64.tar.gz master1# cp ./heketi-client/bin/heketi-cli /usr/local/bin/ master1# heketi-cli heketi-cli v8.0.0 

अब हेकेटी पॉड का आईपी पता ढूंढें और इसे सिस्टम चर के रूप में निर्यात करें:

 master1# kubectl --kubeconfig /etc/kubernetes/admin.conf describe pod deploy-heketi-1211581626-2jotm For me this pod have a 10.42.0.1 ip master1# curl http://10.42.0.1:57598/hello Handling connection for 57598 Hello from Heketi master1# export HEKETI_CLI_SERVER=http://10.42.0.1:57598 

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

नोट। सुनिश्चित करें कि hostnames/manage सटीक नाम इंगित करता है, जैसा कि kubectl get node अनुभाग kubectl get node , और यह कि hostnames/storage स्टोरेज नोड्स का आईपी पता है।

 master1:~/heketi-client# vi topology.json { "clusters": [ { "nodes": [ { "node": { "hostnames": { "manage": [ "worker1" ], "storage": [ "192.168.0.7" ] }, "zone": 1 }, "devices": [ "/dev/loop0" ] }, { "node": { "hostnames": { "manage": [ "worker2" ], "storage": [ "192.168.0.8" ] }, "zone": 1 }, "devices": [ "/dev/loop0" ] }, { "node": { "hostnames": { "manage": [ "worker3" ], "storage": [ "192.168.0.9" ] }, "zone": 1 }, "devices": [ "/dev/loop0" ] } ] } ] } 

फिर इस फ़ाइल को डाउनलोड करें:

 master1:~/heketi-client# heketi-cli topology load --json=topology.json Creating cluster ... ID: e83467d0074414e3f59d3350a93901ef Allowing file volumes on cluster. Allowing block volumes on cluster. Creating node worker1 ... ID: eea131d392b579a688a1c7e5a85e139c Adding device /dev/loop0 ... OK Creating node worker2 ... ID: 300ad5ff2e9476c3ba4ff69260afb234 Adding device /dev/loop0 ... OK Creating node worker3 ... ID: 94ca798385c1099c531c8ba3fcc9f061 Adding device /dev/loop0 ... OK 

इसके बाद, हम डेटाबेस के भंडारण के लिए वॉल्यूम प्रदान करने के लिए हेकेटी का उपयोग करते हैं। टीम का नाम थोड़ा अजीब है, लेकिन सब कुछ क्रम में है। एक हेकेटी रिपॉजिटरी भी बनाएं:

 master1:~/heketi-client# heketi-cli setup-openshift-heketi-storage master1:~/heketi-client# kubectl --kubeconfig /etc/kubernetes/admin.conf create -f heketi-storage.json secret/heketi-storage-secret created endpoints/heketi-storage-endpoints created service/heketi-storage-endpoints created job.batch/heketi-storage-copy-job created 

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

 control# kubectl get pod NAME READY STATUS RESTARTS AGE glusterfs-5dtdj 1/1 Running 0 39h glusterfs-hzdll 1/1 Running 0 39h glusterfs-p8r59 1/1 Running 0 39h heketi-storage-copy-job-txkql 0/1 Completed 0 69s 

और हेकेटी-स्टोरेज-कॉपी-जॉब का काम किया जाता है।

यदि वर्तमान में आपके काम करने वाले नोड्स पर कोई स्थापित ग्लस्टरफ़िश-क्लाइंट पैकेज स्थापित नहीं है, तो एक त्रुटि होती है।

हेतकी बूटस्ट्रैप इंस्टॉलेशन फ़ाइल को हटाने और थोड़ी सफाई करने का समय है:

 control# kubectl delete all,service,jobs,deployment,secret --selector="deploy-heketi" 

अंतिम चरण में, हमें हेकेटी की एक दीर्घकालिक प्रति बनाने की आवश्यकता है:

 control# cd ./heketi/extras/kubernetes control:~/heketi/extras/kubernetes# kubectl create -f heketi-deployment.json secret/heketi-db-backup created service/heketi created deployment.extensions/heketi created control# kubectl get pod NAME READY STATUS RESTARTS AGE glusterfs-5dtdj 1/1 Running 0 39h glusterfs-hzdll 1/1 Running 0 39h glusterfs-p8r59 1/1 Running 0 39h heketi-b8c5f6554-knp7t 1/1 Running 0 22m 

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

गतिशील संसाधन आवंटन के साथ GlusterFS क्लस्टर का उपयोग शुरू करने के लिए, हमें StorageClass बनाने की आवश्यकता है।

सबसे पहले, ग्लस्टर स्टोरेज एंडपॉइंट पाते हैं, जो एक पैरामीटर (हेकेटी-स्टोरेज-एंडपॉइंट) के रूप में StorageClass को पास किया जाएगा:

 control# kubectl get endpoints NAME ENDPOINTS AGE heketi 10.42.0.2:8080 2d16h ....... ... .. 

अब कुछ फ़ाइलें बनाएँ:

 control# vi storage-class.yml apiVersion: storage.k8s.io/v1beta1 kind: StorageClass metadata: name: slow provisioner: kubernetes.io/glusterfs parameters: resturl: "http://10.42.0.2:8080" control# vi test-pvc.yml kind: PersistentVolumeClaim apiVersion: v1 metadata: name: gluster1 annotations: volume.beta.kubernetes.io/storage-class: "slow" spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Gi 

कक्षा और पीवीसी बनाने के लिए इन फ़ाइलों का उपयोग करें:

 control# kubectl create -f storage-class.yaml storageclass "slow" created control# kubectl get storageclass NAME PROVISIONER AGE slow kubernetes.io/glusterfs 2d8h control# kubectl create -f test-pvc.yaml persistentvolumeclaim "gluster1" created control# kubectl get pvc NAME STATUS VOLUME CAPACITY ACCESS MODES STORAGECLASS AGE gluster1 Bound pvc-27f733cd-1c77-11e9-bb07-7efe6b0e6fa5 1Gi RWO slow 2d8h 

हम पीवी वॉल्यूम भी देख सकते हैं:

 control# kubectl get pv NAME CAPACITY ACCESS MODES RECLAIM POLICY STATUS CLAIM STORAGECLASS REASON AGE pvc-27f733cd-1c77-11e9-bb07-7efe6b0e6fa5 1Gi RWO Delete Bound default/gluster1 slow 2d8h 

अब हमारे पास PersistentVolumeClaim के साथ संबद्ध एक गतिशील रूप से बनाया गया GlusterFS वॉल्यूम है, और हम किसी भी सबप्लॉट में इस कथन का उपयोग कर सकते हैं।

Nginx के तहत एक सरल बनाएं और इसका परीक्षण करें:

 control# vi nginx-test.yml apiVersion: v1 kind: Pod metadata: name: nginx-pod1 labels: name: nginx-pod1 spec: containers: - name: nginx-pod1 image: gcr.io/google_containers/nginx-slim:0.8 ports: - name: web containerPort: 80 volumeMounts: - name: gluster-vol1 mountPath: /usr/share/nginx/html volumes: - name: gluster-vol1 persistentVolumeClaim: claimName: gluster1 control# kubectl create -f nginx-test.yaml pod "nginx-pod1" created 

के तहत ब्राउज़ करें (कुछ मिनट प्रतीक्षा करें, आपको छवि डाउनलोड करने की आवश्यकता हो सकती है यदि यह पहले से मौजूद नहीं है):

 control# kubectl get pods NAME READY STATUS RESTARTS AGE glusterfs-5dtdj 1/1 Running 0 4d10h glusterfs-hzdll 1/1 Running 0 4d10h glusterfs-p8r59 1/1 Running 0 4d10h heketi-b8c5f6554-knp7t 1/1 Running 0 2d18h nginx-pod1 1/1 Running 0 47h 

अब कंटेनर में जाएँ और index.html फ़ाइल बनाएँ:

 control# kubectl exec -ti nginx-pod1 /bin/sh # cd /usr/share/nginx/html # echo 'Hello there from GlusterFS pod !!!' > index.html # ls index.html # exit 

आपको किसी भी मास्टर नोड से चूल्हा और कर्ल के आंतरिक आईपी पते को खोजने की आवश्यकता होगी:

 master1# curl 10.40.0.1 Hello there from GlusterFS pod !!! 

ऐसा करने में, हम बस अपनी नई लगातार मात्रा का परीक्षण करते हैं।

नए GlusterFS क्लस्टर की जाँच के लिए कुछ उपयोगी कमांड हैं: heketi-cli cluster list और heketi-cli volume list । यदि हेकेटी-क्लि स्थापित है, तो उन्हें आपके कंप्यूटर पर चलाया जा सकता है । इस उदाहरण में, यह नोड मास्टर 1 है ।

 master1# heketi-cli cluster list Clusters: Id:e83467d0074414e3f59d3350a93901ef [file][block] master1# heketi-cli volume list Id:6fdb7fef361c82154a94736c8f9aa53e Cluster:e83467d0074414e3f59d3350a93901ef Name:vol_6fdb7fef361c82154a94736c8f9aa53e Id:c6b69bd991b960f314f679afa4ad9644 Cluster:e83467d0074414e3f59d3350a93901ef Name:heketidbstorage 

इस स्तर पर, हमने फ़ाइल भंडारण के साथ एक आंतरिक लोड बैलेंसर सफलतापूर्वक स्थापित किया है, और हमारा क्लस्टर अब परिचालन स्थिति के करीब है।

लेख के अगले भाग में, हम एक क्लस्टर मॉनिटरिंग सिस्टम बनाने पर ध्यान केंद्रित करेंगे, और सभी संसाधनों को कॉन्फ़िगर करने के लिए इसमें एक परीक्षण परियोजना भी शुरू करेंगे।

संपर्क में रहें और सभी बेहतरीन!