🗒️ 🍦 🏂🏽 नंगे धातु, निगरानी, लॉग और उपयोग के उदाहरणों पर कुबेरनेट्स हा क्लस्टर को कॉन्फ़िगर करना। भाग 3/3 🚉 🙅 🎽

भाग 1/3 यहाँ ।

भाग 2/3 यहाँ ।

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

कुबेरनेट्स समुदाय द्वारा वेब-आधारित इंटरफ़ेस प्रदान करने और क्लस्टर आँकड़े प्राप्त करने के लिए सबसे लोकप्रिय उपकरण कुबेरनेट्स डैशबोर्ड है । वास्तव में, यह अभी भी विकास के अधीन है, लेकिन अब भी यह एप्लिकेशन समस्याओं के निवारण और क्लस्टर संसाधनों के प्रबंधन के लिए कुछ अतिरिक्त डेटा प्रदान कर सकता है।

विषय आंशिक रूप से विवादास्पद है। क्या यह सच है कि क्लस्टर को प्रबंधित करने के लिए आपको किसी प्रकार के वेब इंटरफ़ेस की आवश्यकता है, या क्या यह कुबेकेल कंसोल टूल का उपयोग करने के लिए पर्याप्त है? खैर, कभी-कभी ये विकल्प एक-दूसरे के पूरक होते हैं।

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

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

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

control# vi kube-dashboard.yaml # Copyright 2017 The Kubernetes Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ------------------- Dashboard Secret ------------------- # apiVersion: v1 kind: Secret metadata: labels: k8s-app: kubernetes-dashboard name: kubernetes-dashboard-certs namespace: kube-system type: Opaque --- # ------------------- Dashboard Service Account ------------------- # apiVersion: v1 kind: ServiceAccount metadata: labels: k8s-app: kubernetes-dashboard name: kubernetes-dashboard namespace: kube-system --- # ------------------- Dashboard Role & Role Binding ------------------- # kind: Role apiVersion: rbac.authorization.k8s.io/v1 metadata: name: kubernetes-dashboard-minimal namespace: kube-system rules: # Allow Dashboard to create 'kubernetes-dashboard-key-holder' secret. - apiGroups: [""] resources: ["secrets"] verbs: ["create"] # Allow Dashboard to create 'kubernetes-dashboard-settings' config map. - apiGroups: [""] resources: ["configmaps"] verbs: ["create"] # Allow Dashboard to get, update and delete Dashboard exclusive secrets. - apiGroups: [""] resources: ["secrets"] resourceNames: ["kubernetes-dashboard-key-holder", "kubernetes-dashboard-certs"] verbs: ["get", "update", "delete"] # Allow Dashboard to get and update 'kubernetes-dashboard-settings' config map. - apiGroups: [""] resources: ["configmaps"] resourceNames: ["kubernetes-dashboard-settings"] verbs: ["get", "update"] # Allow Dashboard to get metrics from heapster. - apiGroups: [""] resources: ["services"] resourceNames: ["heapster"] verbs: ["proxy"] - apiGroups: [""] resources: ["services/proxy"] resourceNames: ["heapster", "http:heapster:", "https:heapster:"] verbs: ["get"] --- apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: kubernetes-dashboard-minimal namespace: kube-system roleRef: apiGroup: rbac.authorization.k8s.io kind: Role name: kubernetes-dashboard-minimal subjects: - kind: ServiceAccount name: kubernetes-dashboard namespace: kube-system --- # ------------------- Dashboard Deployment ------------------- # kind: Deployment apiVersion: apps/v1 metadata: labels: k8s-app: kubernetes-dashboard name: kubernetes-dashboard namespace: kube-system spec: replicas: 1 revisionHistoryLimit: 10 selector: matchLabels: k8s-app: kubernetes-dashboard template: metadata: labels: k8s-app: kubernetes-dashboard spec: containers: - name: kubernetes-dashboard image: k8s.gcr.io/kubernetes-dashboard-amd64:v1.10.1 ports: - containerPort: 8443 protocol: TCP args: - --auto-generate-certificates # Uncomment the following line to manually specify Kubernetes API server Host # If not specified, Dashboard will attempt to auto discover the API server and connect # to it. Uncomment only if the default does not work. # - --apiserver-host=http://my-address:port volumeMounts: - name: kubernetes-dashboard-certs mountPath: /certs # Create on-disk volume to store exec logs - mountPath: /tmp name: tmp-volume livenessProbe: httpGet: scheme: HTTPS path: / port: 8443 initialDelaySeconds: 30 timeoutSeconds: 30 volumes: - name: kubernetes-dashboard-certs secret: secretName: kubernetes-dashboard-certs - name: tmp-volume emptyDir: {} serviceAccountName: kubernetes-dashboard # Comment the following tolerations if Dashboard must not be deployed on master tolerations: - key: node-role.kubernetes.io/master effect: NoSchedule --- # ------------------- Dashboard Service ------------------- # kind: Service apiVersion: v1 metadata: labels: k8s-app: kubernetes-dashboard name: kubernetes-dashboard namespace: kube-system spec: type: LoadBalancer ports: - port: 443 targetPort: 8443 selector: k8s-app: kubernetes-dashboard

फिर चलाएं:

 control# kubectl create -f kube-dashboard.yaml control# kubectl get svc --namespace=kube-system kubernetes-dashboard LoadBalancer 10.96.164.141 192.168.0.240 443:31262/TCP 8h

ठीक है, जैसा कि आप देख सकते हैं, हमारे बीएन ने इस सेवा के लिए आईपी 192.168.0.240 जोड़ा। अब कुबेरनेट्स डैशबोर्ड देखने के लिए https://192.168.0.240 खोलने का प्रयास करें ।

पहुँच प्राप्त करने के 2 तरीके हैं: हमारे मास्टर नोड से admin.conf फ़ाइल का उपयोग करें, जिसका उपयोग हमने पहले kubectl सेट करते समय किया था, या एक सुरक्षा टोकन के साथ एक विशेष सेवा खाता बनाते हैं।

आइए एक व्यवस्थापक उपयोगकर्ता बनाएँ:

 control# vi kube-dashboard-admin.yaml apiVersion: v1 kind: ServiceAccount metadata: name: admin-user namespace: kube-system --- apiVersion: rbac.authorization.k8s.io/v1beta1 kind: ClusterRoleBinding metadata: name: admin-user roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: cluster-admin subjects: - kind: ServiceAccount name: admin-user namespace: kube-system control# kubectl create -f kube-dashboard-admin.yaml serviceaccount/admin-user created clusterrolebinding.rbac.authorization.k8s.io/admin-user created

अब आपको सिस्टम में प्रवेश करने के लिए एक टोकन की आवश्यकता है:

 control# kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | grep admin-user | awk '{print $1}') Name: admin-user-token-vfh66 Namespace: kube-system Labels: <none> Annotations: kubernetes.io/service-account.name: admin-user kubernetes.io/service-account.uid: 3775471a-3620-11e9-9800-763fc8adcb06 Type: kubernetes.io/service-account-token Data ==== ca.crt: 1025 bytes namespace: 11 bytes token: erJhbGciOiJSUzI1NiIsImtpZCI6IiJ9.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwna3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJr dWJlLXN5c3RlbSIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJhZG1pbi11c2VmLXRva2VuLXZmaDY2Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZ XJ2aWNlLWFjY291bnQubmFtZSI6ImFkbWluLXVzZXIiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC51aWQiOiIzNzc1NDcxYS0zNjIwLTExZTktOTgwMC03Nj NmYzhhZGNiMDYiLCJzdWIiOiJzeXN0ZW06c2VydmljZWFjY291bnQ6a3ViZS1zeXN0ZW06YWRtaW4tdXNlciJ9.JICASwxAJHFX8mLoSikJU1tbij4Kq2pneqAt6QCcGUizFLeSqr2R5x339ZR8W4 9cIsbZ7hbhFXCATQcVuWnWXe2dgXP5KE8ZdW9uvq96rm_JvsZz0RZO03UFRf8Exsss6GLeRJ5uNJNCAr8No5pmRMJo-_4BKW4OFDFxvSDSS_ZJaLMqJ0LNpwH1Z09SfD8TNW7VZqax4zuTSMX_yVS ts40nzh4-_IxDZ1i7imnNSYPQa_Oq9ieJ56Q-xuOiGu9C3Hs3NmhwV8MNAcniVEzoDyFmx4z9YYcFPCDIoerPfSJIMFIWXcNlUTPSMRA-KfjSb_KYAErVfNctwOVglgCISA

टोकन को कॉपी करें और लॉगिन स्क्रीन पर टोकन फ़ील्ड में पेस्ट करें।

सिस्टम में प्रवेश करने के बाद, आप क्लस्टर का थोड़ा गहरा अध्ययन कर सकते हैं - मुझे यह उपकरण पसंद है।
हमारे क्लस्टर की निगरानी प्रणाली को गहरा करने की दिशा में अगला कदम हैपस्टर स्थापित करना है ।

हेपरस्टर आपको कंटेनर क्लस्टर की निगरानी करने और कुबेरनेट्स (संस्करण v1.0.6 और उच्चतर) के लिए प्रदर्शन का विश्लेषण करने की अनुमति देता है। यह उपयुक्त मंच प्रदान करता है।

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

नंगे धातु पर इसे स्थापित करने में थोड़ी कठिनाई होती है, और मुझे कुछ जांच करने की आवश्यकता थी: उपकरण मूल संस्करण में काम क्यों नहीं करता है, लेकिन मुझे एक समाधान मिला।

तो चलिए जारी रखते हैं और इस ऐड को एंडोर्स करते हैं:

 control# vi heapster.yaml apiVersion: v1 kind: ServiceAccount metadata: name: heapster namespace: kube-system --- apiVersion: extensions/v1beta1 kind: Deployment metadata: name: heapster namespace: kube-system spec: replicas: 1 template: metadata: labels: task: monitoring k8s-app: heapster spec: serviceAccountName: heapster containers: - name: heapster image: gcr.io/google_containers/heapster-amd64:v1.4.2 imagePullPolicy: IfNotPresent command: - /heapster - --source=kubernetes.summary_api:''?useServiceAccount=true&kubeletHttps=true&kubeletPort=10250&insecure=true --- apiVersion: v1 kind: Service metadata: labels: task: monitoring # For use as a Cluster add-on (https://github.com/kubernetes/kubernetes/tree/master/cluster/addons) # If you are NOT using this as an addon, you should comment out this line. kubernetes.io/cluster-service: 'true' kubernetes.io/name: Heapster name: heapster namespace: kube-system spec: ports: - port: 80 targetPort: 8082 selector: k8s-app: heapster --- kind: ClusterRoleBinding apiVersion: rbac.authorization.k8s.io/v1beta1 metadata: name: heapster roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: system:heapster subjects: - kind: ServiceAccount name: heapster namespace: kube-system

यह हैपस्टर समुदाय की सबसे सामान्य मानक परिनियोजन फ़ाइल है, केवल थोड़े से अंतर के साथ: यह हमारे क्लस्टर पर काम करने के लिए, हैपरस्टर तैनाती में लाइन " स्रोत = " को निम्नानुसार बदला गया है:

 --source=kubernetes.summary_api:''?useServiceAccount=true&kubeletHttps=true&kubeletPort=10250&insecure=true

इस विवरण में आपको ये सभी विकल्प मिलेंगे। मैंने क्यूबलेट पोर्ट को 10250 में बदल दिया और ssl प्रमाणपत्र सत्यापन को बंद कर दिया (इसमें थोड़ी समस्या थी)।

हमें Heapster RBAC भूमिका में नोड आँकड़े प्राप्त करने के लिए अनुमतियाँ जोड़ने की भी आवश्यकता है; भूमिका के अंत में इन कुछ पंक्तियों को जोड़ें:

 control# kubectl edit clusterrole system:heapster ...... ... - apiGroups: - "" resources: - nodes/stats verbs: - get

सारांश में, आपकी RBAC भूमिका इस तरह दिखनी चाहिए:

 # Please edit the object below. Lines beginning with a '#' will be ignored, # and an empty file will abort the edit. If an error occurs while saving this file will be # reopened with the relevant failures. # apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: annotations: rbac.authorization.kubernetes.io/autoupdate: "true" creationTimestamp: "2019-02-22T18:58:32Z" labels: kubernetes.io/bootstrapping: rbac-defaults name: system:heapster resourceVersion: "6799431" selfLink: /apis/rbac.authorization.k8s.io/v1/clusterroles/system%3Aheapster uid: d99065b5-36d3-11e9-a7e6-763fc8adcb06 rules: - apiGroups: - "" resources: - events - namespaces - nodes - pods verbs: - get - list - watch - apiGroups: - extensions resources: - deployments verbs: - get - list - watch - apiGroups: - "" resources: - nodes/stats verbs: - get

ठीक है, अब चलिए यह सुनिश्चित करने के लिए कमांड चलाते हैं कि हेल्पर की तैनाती सफलतापूर्वक शुरू की गई है।

 control# kubectl top node NAME CPU(cores) CPU% MEMORY(bytes) MEMORY% kube-master1 183m 9% 1161Mi 60% kube-master2 235m 11% 1130Mi 59% kube-worker1 189m 4% 1216Mi 41% kube-worker2 218m 5% 1290Mi 44% kube-worker3 181m 4% 1305Mi 44%

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

अब से, हम क्लस्टर नोड्स, हार्ट्स आदि के लिए संसाधनों के वास्तविक उपयोग को भी ट्रैक कर सकते हैं।

यदि यह पर्याप्त नहीं है, तो आप InfluxDB + Grafana को जोड़कर आँकड़ों को बेहतर बना सकते हैं। यह आपके स्वयं के ग्रेफाना पैनलों को खींचने की क्षमता को जोड़ देगा।

हम Heapster Git पृष्ठ से InfluxDB + Grafana स्थापना के इस संस्करण का उपयोग करेंगे, लेकिन, हमेशा की तरह, हम सुधार करेंगे। चूँकि हम पहले से ही तैनात हैस्टर को कॉन्फ़िगर कर चुके हैं, इसलिए हमें केवल Grafana और InfluxDB को जोड़ने की आवश्यकता है, और फिर मौजूदा heapster को संशोधित करें ताकि वह Influx में मेट्रिक्स भी डाल सके।

ठीक है, चलो इन्फ्लक्सडीबी और ग्रेफाना तैनाती बनाएं:

 control# vi influxdb.yaml apiVersion: extensions/v1beta1 kind: Deployment metadata: name: monitoring-influxdb namespace: kube-system spec: replicas: 1 template: metadata: labels: task: monitoring k8s-app: influxdb spec: containers: - name: influxdb image: k8s.gcr.io/heapster-influxdb-amd64:v1.5.2 volumeMounts: - mountPath: /data name: influxdb-storage volumes: - name: influxdb-storage emptyDir: {} --- apiVersion: v1 kind: Service metadata: labels: task: monitoring # For use as a Cluster add-on (https://github.com/kubernetes/kubernetes/tree/master/cluster/addons) # If you are NOT using this as an addon, you should comment out this line. kubernetes.io/cluster-service: 'true' kubernetes.io/name: monitoring-influxdb name: monitoring-influxdb namespace: kube-system spec: ports: - port: 8086 targetPort: 8086 selector: k8s-app: influxdb

अगला अप ग्रेफाना है, और मेटाला लोड लोडर को सक्षम करने और ग्रेफाना सेवा के लिए बाहरी आईपी पता प्राप्त करने के लिए सेवा सेटिंग्स को बदलना न भूलें।

 control# vi grafana.yaml apiVersion: extensions/v1beta1 kind: Deployment metadata: name: monitoring-grafana namespace: kube-system spec: replicas: 1 template: metadata: labels: task: monitoring k8s-app: grafana spec: containers: - name: grafana image: k8s.gcr.io/heapster-grafana-amd64:v5.0.4 ports: - containerPort: 3000 protocol: TCP volumeMounts: - mountPath: /etc/ssl/certs name: ca-certificates readOnly: true - mountPath: /var name: grafana-storage env: - name: INFLUXDB_HOST value: monitoring-influxdb - name: GF_SERVER_HTTP_PORT value: "3000" # The following env variables are required to make Grafana accessible via # the kubernetes api-server proxy. On production clusters, we recommend # removing these env variables, setup auth for grafana, and expose the grafana # service using a LoadBalancer or a public IP. - name: GF_AUTH_BASIC_ENABLED value: "false" - name: GF_AUTH_ANONYMOUS_ENABLED value: "true" - name: GF_AUTH_ANONYMOUS_ORG_ROLE value: Admin - name: GF_SERVER_ROOT_URL # If you're only using the API Server proxy, set this value instead: # value: /api/v1/namespaces/kube-system/services/monitoring-grafana/proxy value: / volumes: - name: ca-certificates hostPath: path: /etc/ssl/certs - name: grafana-storage emptyDir: {} --- apiVersion: v1 kind: Service metadata: labels: # For use as a Cluster add-on (https://github.com/kubernetes/kubernetes/tree/master/cluster/addons) # If you are NOT using this as an addon, you should comment out this line. kubernetes.io/cluster-service: 'true' kubernetes.io/name: monitoring-grafana name: monitoring-grafana namespace: kube-system spec: # In a production setup, we recommend accessing Grafana through an external Loadbalancer # or through a public IP. # type: LoadBalancer # You could also use NodePort to expose the service at a randomly-generated port # type: NodePort type: LoadBalancer ports: - port: 80 targetPort: 3000 selector: k8s-app: grafana

और उन्हें बनाएँ:

 control# kubectl create -f influxdb.yaml deployment.extensions/monitoring-influxdb created service/monitoring-influxdb created control# kubectl create -f grafana.yaml deployment.extensions/monitoring-grafana created service/monitoring-grafana created

यह समय है कि हेल्पर की तैनाती को बदल दिया जाए और इसमें इन्फ्लक्सडीबी कनेक्शन जोड़ दिया जाए; आपको बस एक पंक्ति जोड़ने की आवश्यकता है:

 - --sink=influxdb:http://monitoring-influxdb.kube-system.svc:8086

हथियार तैनात तैनात करें:

 control# kubectl get deployments --namespace=kube-system NAME READY UP-TO-DATE AVAILABLE AGE coredns 2/2 2 2 49d heapster 1/1 1 1 2d12h kubernetes-dashboard 1/1 1 1 3d21h monitoring-grafana 1/1 1 1 115s monitoring-influxdb 1/1 1 1 2m18s control# kubectl edit deployment heapster --namespace=kube-system ... beginning bla bla bla spec: containers: - command: - /heapster - --source=kubernetes.summary_api:''?useServiceAccount=true&kubeletHttps=true&kubeletPort=10250&insecure=true - --sink=influxdb:http://monitoring-influxdb.kube-system.svc:8086 image: gcr.io/google_containers/heapster-amd64:v1.4.2 imagePullPolicy: IfNotPresent .... end

अब Grafana सेवा का बाहरी IP पता ढूंढें और इसके अंदर सिस्टम में लॉग इन करें:

 control# kubectl get svc --namespace=kube-system NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE ..... some other services here monitoring-grafana LoadBalancer 10.98.111.200 192.168.0.241 80:32148/TCP 18m

ब्राउज़र में http://192.168.0.241 खोलें, पहली बार व्यवस्थापक / व्यवस्थापक क्रेडेंशियल्स का उपयोग करें:

जब मैंने लॉग इन किया, तो मेरा ग्राफाना खाली था, लेकिन, सौभाग्य से, हम grafana.com से सभी आवश्यक डैशबोर्ड प्राप्त कर सकते हैं। आपको पैनल नंबर 3649 और 3646 आयात करने की आवश्यकता है। आयात करते समय, सही डेटा स्रोत का चयन करें।

उसके बाद, नोड्स और चूल्हा के संसाधनों के उपयोग की निगरानी करें और निश्चित रूप से, अपने स्वयं के अनूठे डैशबोर्ड बनाएं।

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

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

मैं एलीमैटिक्स और किबाना प्रतिष्ठानों के साथ एक वीएम बनाने के बारे में भाग को छोड़ दूंगा; यह एक काफी लोकप्रिय विषय है, इसलिए आप इसे करने के लिए सबसे अच्छी सामग्री पा सकते हैं। उदाहरण के लिए, मेरे लेख में । बस docker -compose.yml फ़ाइल से लॉगस्टैश कॉन्फ़िगरेशन फ़्रेग्मेंट को निकालें, और इलास्टिसर्च पोर्ट्स अनुभाग से 127.0.0.1 भी निकालें।

उसके बाद, आपके पास VM-IP पोर्ट: 9200 से जुड़ी एक कार्यशील इलास्टिक्स खोज होनी चाहिए। अतिरिक्त सुरक्षा के लिए, लॉगिन कॉन्फ़िगर करें: धाराप्रवाह और इलास्टिक्स खोज के बीच पास या सुरक्षा कुंजी। हालाँकि, मैं अक्सर उन्हें iptables नियमों से सुरक्षित रखता हूं।

जो कुछ भी करना बाकी है, वह कुबेरनेट्स में एक धाराप्रवाह डेमोंसेट बनाने और इलास्टिक्स खोज नोड निर्दिष्ट करने के लिए है: कॉन्फ़िगरेशन में बाहरी पता।

हम मामूली संशोधनों के साथ यमल कॉन्फ़िगरेशन के साथ आधिकारिक कुबेरनेट्स ऐड-ऑन का उपयोग करते हैं:

 control# vi fluentd-es-ds.yaml apiVersion: v1 kind: ServiceAccount metadata: name: fluentd-es namespace: kube-system labels: k8s-app: fluentd-es kubernetes.io/cluster-service: "true" addonmanager.kubernetes.io/mode: Reconcile --- kind: ClusterRole apiVersion: rbac.authorization.k8s.io/v1 metadata: name: fluentd-es labels: k8s-app: fluentd-es kubernetes.io/cluster-service: "true" addonmanager.kubernetes.io/mode: Reconcile rules: - apiGroups: - "" resources: - "namespaces" - "pods" verbs: - "get" - "watch" - "list" --- kind: ClusterRoleBinding apiVersion: rbac.authorization.k8s.io/v1 metadata: name: fluentd-es labels: k8s-app: fluentd-es kubernetes.io/cluster-service: "true" addonmanager.kubernetes.io/mode: Reconcile subjects: - kind: ServiceAccount name: fluentd-es namespace: kube-system apiGroup: "" roleRef: kind: ClusterRole name: fluentd-es apiGroup: "" --- apiVersion: apps/v1 kind: DaemonSet metadata: name: fluentd-es-v2.4.0 namespace: kube-system labels: k8s-app: fluentd-es version: v2.4.0 kubernetes.io/cluster-service: "true" addonmanager.kubernetes.io/mode: Reconcile spec: selector: matchLabels: k8s-app: fluentd-es version: v2.4.0 template: metadata: labels: k8s-app: fluentd-es kubernetes.io/cluster-service: "true" version: v2.4.0 # This annotation ensures that fluentd does not get evicted if the node # supports critical pod annotation based priority scheme. # Note that this does not guarantee admission on the nodes (#40573). annotations: scheduler.alpha.kubernetes.io/critical-pod: '' seccomp.security.alpha.kubernetes.io/pod: 'docker/default' spec: priorityClassName: system-node-critical serviceAccountName: fluentd-es containers: - name: fluentd-es image: k8s.gcr.io/fluentd-elasticsearch:v2.4.0 env: - name: FLUENTD_ARGS value: --no-supervisor -q resources: limits: memory: 500Mi requests: cpu: 100m memory: 200Mi volumeMounts: - name: varlog mountPath: /var/log - name: varlibdockercontainers mountPath: /var/lib/docker/containers readOnly: true - name: config-volume mountPath: /etc/fluent/config.d terminationGracePeriodSeconds: 30 volumes: - name: varlog hostPath: path: /var/log - name: varlibdockercontainers hostPath: path: /var/lib/docker/containers - name: config-volume configMap: name: fluentd-es-config-v0.2.0

फिर हम धाराप्रवाह का एक विशिष्ट विन्यास करेंगे:

 control# vi fluentd-es-configmap.yaml kind: ConfigMap apiVersion: v1 metadata: name: fluentd-es-config-v0.2.0 namespace: kube-system labels: addonmanager.kubernetes.io/mode: Reconcile data: system.conf: |- <system> root_dir /tmp/fluentd-buffers/ </system> containers.input.conf: |-

  @id fluentd-containers.log @type tail path /var/log/containers/*.log pos_file /var/log/es-containers.log.pos tag raw.kubernetes.* read_from_head true <parse> @type multi_format <pattern> format json time_key time time_format %Y-%m-%dT%H:%M:%S.%NZ </pattern> <pattern> format /^(?<time>.+) (?<stream>stdout|stderr) [^ ]* (?<log>.*)$/ time_format %Y-%m-%dT%H:%M:%S.%N%:z </pattern> </parse>

 # Detect exceptions in the log output and forward them as one log entry. <match raw.kubernetes.**> @id raw.kubernetes @type detect_exceptions remove_tag_prefix raw message log stream stream multiline_flush_interval 5 max_bytes 500000 max_lines 1000 </match> # Concatenate multi-line logs <filter **> @id filter_concat @type concat key message multiline_end_regexp /\n$/ separator "" </filter> # Enriches records with Kubernetes metadata <filter kubernetes.**> @id filter_kubernetes_metadata @type kubernetes_metadata </filter> # Fixes json fields in Elasticsearch <filter kubernetes.**> @id filter_parser @type parser key_name log reserve_data true remove_key_name_field true <parse> @type multi_format <pattern> format json </pattern> <pattern> format none </pattern> </parse> </filter> output.conf: |- <match **> @id elasticsearch @type elasticsearch @log_level info type_name _doc include_tag_key true host 192.168.1.253 port 9200 logstash_format true <buffer> @type file path /var/log/fluentd-buffers/kubernetes.system.buffer flush_mode interval retry_type exponential_backoff flush_thread_count 2 flush_interval 5s retry_forever retry_max_interval 30 chunk_limit_size 2M queue_limit_length 8 overflow_action block </buffer> </match>

कॉन्फ़िगरेशन प्राथमिक है, लेकिन यह एक त्वरित शुरुआत के लिए पर्याप्त है; यह सिस्टम और एप्लिकेशन लॉग एकत्र करेगा। यदि आपको कुछ अधिक जटिल चाहिए, तो आप धाराप्रवाह प्लगइन्स और कुबेरनेट कॉन्फ़िगरेशन पर आधिकारिक दस्तावेज देख सकते हैं।

अब हमारे क्लस्टर में एक धाराप्रवाह डेमोंसेट बनाएँ:

 control# kubectl create -f fluentd-es-ds.yaml serviceaccount/fluentd-es created clusterrole.rbac.authorization.k8s.io/fluentd-es created clusterrolebinding.rbac.authorization.k8s.io/fluentd-es created daemonset.apps/fluentd-es-v2.4.0 created control# kubectl create -f fluentd-es-configmap.yaml configmap/fluentd-es-config-v0.2.0 created

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

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

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

इस उदाहरण के लिए, मेरे छोटे पायथन / फ्लास्क कुबिक एप्लिकेशन को लें, जिसमें पहले से डॉकटर कंटेनर है, इसलिए इसे डॉक ओपन रजिस्ट्री से लें। अब हम इस एप्लिकेशन में एक बाहरी डेटाबेस फ़ाइल जोड़ेंगे - इसके लिए हम कॉन्फ़िगर किए गए GlusterFS भंडारण का उपयोग करेंगे।

सबसे पहले, हम इस एप्लिकेशन (स्थायी वॉल्यूम अनुरोध) के लिए एक नया पीवीसी वॉल्यूम बनाते हैं, जहां हम उपयोगकर्ता क्रेडेंशियल्स के साथ SQLite डेटाबेस को स्टोर करेंगे। आप इस गाइड के भाग 2 से पूर्व-निर्मित मेमोरी क्लास का उपयोग कर सकते हैं।

 control# mkdir kubyk && cd kubyk control# vi kubyk-pvc.yaml kind: PersistentVolumeClaim apiVersion: v1 metadata: name: kubyk annotations: volume.beta.kubernetes.io/storage-class: "slow" spec: accessModes: - ReadWriteOnce resources: requests: storage: 1Gi control# kubectl create -f kubyk-pvc.yaml

आवेदन के लिए एक नया पीवीसी बनाने के बाद, हम तैनाती के लिए तैयार हैं।

 control# vi kubyk-deploy.yaml apiVersion: apps/v1 kind: Deployment metadata: name: kubyk-deployment spec: selector: matchLabels: app: kubyk replicas: 1 template: metadata: labels: app: kubyk spec: containers: - name: kubyk image: ratibor78/kubyk ports: - containerPort: 80 volumeMounts: - name: kubyk-db mountPath: /kubyk/sqlite volumes: - name: kubyk-db persistentVolumeClaim: claimName: kubyk control# vi kubyk-service.yaml apiVersion: v1 kind: Service metadata: name: kubyk spec: type: LoadBalancer selector: app: kubyk ports: - port: 80 name: http

अब एक तैनाती और सेवा बनाएँ:

 control# kubectl create -f kubyk-deploy.yaml deployment.apps/kubyk-deployment created control# kubectl create -f kubyk-service.yaml service/kubyk created

सेवा को सौंपे गए नए आईपी पते की जाँच करें, साथ ही उप की स्थिति:

 control# kubectl get po NAME READY STATUS RESTARTS AGE glusterfs-2wxk7 1/1 Running 1 2d1h glusterfs-5dtdj 1/1 Running 1 41d glusterfs-zqxwt 1/1 Running 0 2d1h heketi-b8c5f6554-f92rn 1/1 Running 0 8d kubyk-deployment-75d5447d46-jrttp 1/1 Running 0 11s control# kubectl get svc NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE ... some text.. kubyk LoadBalancer 10.109.105.224 192.168.0.242 80:32384/TCP 10s

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

कुबेरनेट्स डैशबोर्ड में चूल्हा से लॉग त्रुटि संदेश का एक उदाहरण इस प्रकार है:

इसे ठीक करने के लिए, आपको मेरे git रिपॉजिटरी से SQlite DB फाइल को पहले बनाए गए पीवीसी वॉल्यूम में कॉपी करना होगा। एप्लिकेशन इस डेटाबेस का उपयोग करना शुरू कर देगा।

 control# git pull https://github.com/ratibor78/kubyk.git control# kubectl cp ./kubyk/sqlite/database.db kubyk-deployment-75d5447d46-jrttp:/kubyk/sqlite

हम इस फ़ाइल को वॉल्यूम पर कॉपी करने के लिए एप्लिकेशन और kubectl cp कमांड के तहत उपयोग करते हैं।
आपको इस निर्देशिका में nginx उपयोगकर्ता को लिखना भी देना होगा; मेरे आवेदन की देखरेख के लिए nginx उपयोगकर्ता के माध्यम से लॉन्च किया गया है।

 control# kubectl exec -ti kubyk-deployment-75d5447d46-jrttp -- chown -R nginx:nginx /kubyk/sqlite/

आइए फिर से लॉग इन करने का प्रयास करें:

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

 control# kubectl get deployments NAME READY UP-TO-DATE AVAILABLE AGE heketi 1/1 1 1 39d kubyk-deployment 1/1 1 1 4h5m control# kubectl scale deployments kubyk-deployment --replicas=3 deployment.extensions/kubyk-deployment scaled control# kubectl get po NAME READY STATUS RESTARTS AGE glusterfs-2wxk7 1/1 Running 1 2d5h glusterfs-5dtdj 1/1 Running 21 41d glusterfs-zqxwt 1/1 Running 0 2d5h heketi-b8c5f6554-f92rn 1/1 Running 0 8d kubyk-deployment-75d5447d46-bdnqx 1/1 Running 0 26s kubyk-deployment-75d5447d46-jrttp 1/1 Running 0 4h7m kubyk-deployment-75d5447d46-wz9xz 1/1 Running 0 26s

अब हमारे पास प्रत्येक कार्यशील नोड के लिए आवेदन प्रतिकृतियां हैं, इसलिए यदि कोई नोड खो देता है तो एप्लिकेशन काम करना बंद नहीं करेगा। इसके अलावा, हमें लोड को संतुलित करने का एक सरल तरीका मिलता है, जैसा कि मैंने पहले कहा था। शुरू करने के लिए एक बुरी जगह नहीं है।

आइए हमारे एप्लिकेशन में एक नया उपयोगकर्ता बनाएं:

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

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

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

पुनश्च

स्थिरता परीक्षण और तनाव परीक्षण, निश्चित रूप से।

हमारे उदाहरण से क्लस्टर आरेख 2 काम करने वाले नोड्स, 1 मास्टर नोड्स, और 1 etcd नोड्स के बिना काम करता है। यदि आप चाहते हैं, तो उन्हें अक्षम करें और जांचें कि क्या परीक्षण एप्लिकेशन कार्य करेगा।

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

ऑल द बेस्ट और, मुझे आशा है, जल्द ही मिलेंगे!

नंगे धातु, निगरानी, ​​लॉग और उपयोग के उदाहरणों पर कुबेरनेट्स हा क्लस्टर को कॉन्फ़िगर करना। भाग 3/3

पुनश्च

More articles:

नंगे धातु, निगरानी, लॉग और उपयोग के उदाहरणों पर कुबेरनेट्स हा क्लस्टर को कॉन्फ़िगर करना। भाग 3/3