कुबेरनेट के साथ नंगे धातु पर कुबेरनेट्स हा क्लस्टर को कॉन्फ़िगर करें। भाग १/३

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

सभी को नमस्कार! इस लेख में मैं जानकारी को सुव्यवस्थित करना और कुबेरनेट्स आंतरिक क्लस्टर बनाने और उपयोग करने का अनुभव साझा करना चाहता हूं।

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

0. परिचय

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

1. परिचय

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

सामान्य तौर पर, कुबेरनेट्स हा क्लस्टर बनाने के कई तरीके हैं: लोकप्रिय कुबेरनेट्स-द-हार्ड- डॉक्यूमेंट में वर्णित कठिन और गहराई से रास्ता, या कुबेदम उपयोगिता का उपयोग करके सरल तरीका।

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

स्टड और एक्सटर्नल वल्ड टोपोलॉजी के साथ, क्लस्टर को लागू करने के लिए कुबेदम प्रलेखन दो बुनियादी तरीके प्रदान करता है। मैं HA क्लस्टर के दोष सहिष्णुता के कारण बाहरी etcd नोड्स के साथ दूसरा रास्ता चुनूंगा।

इस मार्ग का वर्णन करने वाले कुबेदम प्रलेखन से एक चित्र यहां दिया गया है:

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

इस कुबेरनेट क्लस्टर योजना के लिए, आठ नोड्स की आवश्यकता होती है। बाहरी क्लस्टर etcd के लिए तीन सर्वर (LB सेवाएं उनमें से एक जोड़े का भी उपयोग करेंगी), नियंत्रण विमान के नोड्स के लिए दो (मास्टर नोड्स) और तीन काम करने वाले नोड्स के लिए। यह या तो नंगे धातु या एक वीएम सर्वर हो सकता है। इस मामले में, इससे कोई फर्क नहीं पड़ता। अधिक निशुल्क सर्वर होने पर आप अधिक मास्टर नोड्स जोड़कर और हृदय की धड़कन के साथ HAProxy को अलग-अलग नोड्स में जोड़कर आसानी से योजना को बदल सकते हैं। यद्यपि HA क्लस्टर के पहले कार्यान्वयन के लिए मेरा विकल्प आंखों के लिए पर्याप्त है।

यदि आप चाहें, तो इस क्लस्टर को प्रबंधित करने के लिए स्थापित kubectl उपयोगिता के साथ एक छोटा सर्वर जोड़ें या इसके लिए अपने स्वयं के लिनक्स डेस्कटॉप का उपयोग करें।

इस उदाहरण का आरेख कुछ इस तरह दिखेगा:

2. आवश्यकताएँ

आपको न्यूनतम अनुशंसित सिस्टम आवश्यकताओं के साथ दो कुबेरनेट्स मास्टर नोड्स की आवश्यकता होगी: कुबेदम प्रलेखन के अनुसार 2 सीपीयू और 2 जीबी रैम। काम करने वाले नोड्स के लिए, मैं अधिक शक्तिशाली सर्वरों का उपयोग करने की सलाह देता हूं, क्योंकि हम उन पर अपनी सभी एप्लिकेशन सेवाओं को चलाएंगे। और Etcd + LB के लिए, हम दो CPU और कम से कम 2 GB RAM वाले सर्वर भी ले सकते हैं।

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

इस उदाहरण के लिए न्यूनतम आवश्यकताएं हैं:

• मास्टर नोड के लिए 2 प्रोसेसर 2 प्रोसेसर और 2 जीबी रैम के साथ
• काम करने वाले नोड्स के लिए 4 प्रोसेसर और 4-8 जीबी रैम के साथ 3 सर्वर
• 2 सर्वरों के साथ 3 प्रोसेसर और 2 जीबी रैम के लिए Etcd और HAProxy
• 192.168.0.0/24 - सबनेट।

192.168.0.1 - HAProxy का वर्चुअल IP पता, 192.168.0.2 - Etcd के 4 मुख्य IP पते और HAProxy नोड्स, 192.168.0.5 - कुबेरनेट्स मास्टर नोड के 6 मुख्य IP पते, 192.168.0.7 - कुबेरनेट्स नोड्स के 9 मुख्य आईपी पते। ।

डेबियन 9 डेटाबेस सभी सर्वरों पर स्थापित है।

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

3. HAProxy और दिल की धड़कन को कॉन्फ़िगर करें।

हमारे पास एक से अधिक Kubernetes मास्टर नोड हैं, और इसलिए आपको उनके सामने एक HAProxy लोड बैलेंसर कॉन्फ़िगर करने की आवश्यकता है - ट्रैफ़िक वितरित करने के लिए। यह एक साझा वर्चुअल IP पते के साथ HAProxy सर्वर की एक जोड़ी होगी। हार्टबीट पैकेज के साथ दोष सहिष्णुता प्रदान की जाती है। तैनाती के लिए, हम पहले दो etcd सर्वर का उपयोग करेंगे।

पहले उदाहरण के लिए हार्टबीट के साथ HAProxy को स्थापित करें और कॉन्फ़िगर करें (192.168.0.23 इस उदाहरण में):

etcd1# apt-get update && apt-get upgrade && apt-get install -y haproxy etcd2# apt-get update && apt-get upgrade && apt-get install -y haproxy 

मूल कॉन्फ़िगरेशन को सहेजें और एक नया बनाएँ:

 etcd1# mv /etc/haproxy/haproxy.cfg{,.back} etcd1# vi /etc/haproxy/haproxy.cfg etcd2# mv /etc/haproxy/haproxy.cfg{,.back} etcd2# vi /etc/haproxy/haproxy.cfg 

दोनों HAProxy के लिए ये कॉन्फ़िगरेशन विकल्प जोड़ें:

 global user haproxy group haproxy defaults mode http log global retries 2 timeout connect 3000ms timeout server 5000ms timeout client 5000ms frontend kubernetes bind 192.168.0.1:6443 option tcplog mode tcp default_backend kubernetes-master-nodes backend kubernetes-master-nodes mode tcp balance roundrobin option tcp-check server k8s-master-0 192.168.0.5:6443 check fall 3 rise 2 server k8s-master-1 192.168.0.6:6443 check fall 3 rise 2 

जैसा कि आप देख सकते हैं, दोनों HAProxy सेवाएं IP पता - 192.168.0.1 साझा करती हैं। यह वर्चुअल आईपी एड्रेस सर्वरों के बीच चला जाएगा, इसलिए हम थोड़ा चालाक होंगे और सिस्टम सेवाओं को गैर-स्थानीय आईपी पते पर बाइंड करने की अनुमति देने के लिए net.ipv4.ip_nonlocal_bind पैरामीटर को सक्षम करेंगे।

इस सुविधा को /etc/sysctl.conf फ़ाइल में जोड़ें :

 etcd1# vi /etc/sysctl.conf net.ipv4.ip_nonlocal_bind=1 etcd2# vi /etc/sysctl.conf net.ipv4.ip_nonlocal_bind=1 

दोनों सर्वरों पर चलाएँ:

 sysctl -p 

दोनों सर्वरों पर HAProxy चलाएं:

 etcd1# systemctl start haproxy etcd2# systemctl start haproxy 

सुनिश्चित करें कि HAProxy चल रहा है और दोनों सर्वरों पर वर्चुअल आईपी एड्रेस सुन रहा है:

 etcd1# netstat -ntlp tcp 0 0 192.168.0.1:6443 0.0.0.0:* LISTEN 2833/haproxy etcd2# netstat -ntlp tcp 0 0 192.168.0.1:6443 0.0.0.0:* LISTEN 2833/haproxy 

अच्छा है! अब हार्टबीट इंस्टॉल करें और इस वर्चुअल आईपी को कॉन्फ़िगर करें।

 etcd1# apt-get -y install heartbeat && systemctl enable heartbeat etcd2# apt-get -y install heartbeat && systemctl enable heartbeat 

यह इसके लिए कई कॉन्फ़िगरेशन फ़ाइलें बनाने का समय है: पहले और दूसरे सर्वर के लिए, वे मूल रूप से समान होंगे।

सबसे पहले फ़ाइल /etc/ha.d/authkeys बनाएं , इस फ़ाइल में हार्टबीट आपसी प्रमाणीकरण के लिए डेटा संग्रहीत करता है। फ़ाइल दोनों सर्वरों पर समान होनी चाहिए:

 # echo -n securepass | md5sum bb77d0d3b3f239fa5db73bdf27b8d29a etcd1# vi /etc/ha.d/authkeys auth 1 1 md5 bb77d0d3b3f239fa5db73bdf27b8d29a etcd2# vi /etc/ha.d/authkeys auth 1 1 md5 bb77d0d3b3f239fa5db73bdf27b8d29a 

यह फ़ाइल केवल रूट करने के लिए सुलभ होनी चाहिए:

 etcd1# chmod 600 /etc/ha.d/authkeys etcd2# chmod 600 /etc/ha.d/authkeys 

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

/Etc/ha.d/ha.cf बनाएं:

etcd1

 etcd1# vi /etc/ha.d/ha.cf # keepalive: how many seconds between heartbeats # keepalive 2 # # deadtime: seconds-to-declare-host-dead # deadtime 10 # # What UDP port to use for udp or ppp-udp communication? # udpport 694 bcast ens18 mcast ens18 225.0.0.1 694 1 0 ucast ens18 192.168.0.3 # What interfaces to heartbeat over? udp ens18 # # Facility to use for syslog()/logger (alternative to log/debugfile) # logfacility local0 # # Tell what machines are in the cluster # node nodename ... -- must match uname -n node etcd1_hostname node etcd2_hostname 

etcd2

 etcd2# vi /etc/ha.d/ha.cf # keepalive: how many seconds between heartbeats # keepalive 2 # # deadtime: seconds-to-declare-host-dead # deadtime 10 # # What UDP port to use for udp or ppp-udp communication? # udpport 694 bcast ens18 mcast ens18 225.0.0.1 694 1 0 ucast ens18 192.168.0.2 # What interfaces to heartbeat over? udp ens18 # # Facility to use for syslog()/logger (alternative to vlog/debugfile) # logfacility local0 # # Tell what machines are in the cluster # node nodename ... -- must match uname -n node etcd1_hostname node etcd2_hostname 

इस कॉन्फ़िगरेशन के लिए "नोड" पैरामीटर प्राप्त करें, दोनों Etcd सर्वर पर uname -n चलाकर। इसके अलावा अपने नेटवर्क कार्ड के नाम का उपयोग सुनिश्चित 18 के बजाय करें।

अंत में, आपको इन सर्वरों पर /etc/ha.d/haresource फ़ाइल बनानी होगी। दोनों सर्वरों के लिए, फ़ाइल समान होनी चाहिए। इस फ़ाइल में, हम अपना सामान्य IP पता सेट करते हैं और निर्धारित करते हैं कि कौन सा नोड डिफ़ॉल्ट मास्टर है:

 etcd1# vi /etc/ha.d/haresources etcd1_hostname 192.168.0.1 etcd2# vi /etc/ha.d/haresources etcd1_hostname 192.168.0.1 

जब सब कुछ तैयार हो जाता है, तो दोनों सर्वरों पर हार्टबीट सेवाएं शुरू करें और सत्यापित करें कि हमने इस घोषित वर्चुअल आईपी को etcd1 नोड पर प्राप्त किया है :

 etcd1# systemctl restart heartbeat etcd2# systemctl restart heartbeat etcd1# ip a ens18: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000 link/ether xx:xx:xx:xx:xx:xx brd ff:ff:ff:ff:ff:ff inet 192.168.0.2/24 brd 192.168.0.255 scope global ens18 valid_lft forever preferred_lft forever inet 192.168.0.1/24 brd 192.168.0.255 scope global secondary 

आप यह सत्यापित कर सकते हैं कि HAProxy 192.168.0.1 6443 पर nc चलाकर ठीक काम कर रहा है। आपने समय समाप्त कर लिया होगा क्योंकि Kubernetes API अभी तक सर्वर की तरफ नहीं सुन रहा है। लेकिन इसका मतलब है कि HAProxy और हार्टबीट को सही तरीके से कॉन्फ़िगर किया गया है।

 # nc -v 192.168.0.1 6443 Connection to 93.158.95.90 6443 port [tcp/*] succeeded! 

4. कुबेरनेट्स के लिए नोड्स तैयार करना

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

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

सभी नोड्स पर डॉकर स्थापित करें:

 Update the apt package index # apt-get update Install packages to allow apt to use a repository over HTTPS # apt-get -y install \ apt-transport-https \ ca-certificates \ curl \ gnupg2 \ software-properties-common Add Docker's official GPG key # curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add - Add docker apt repository # apt-add-repository \ "deb [arch=amd64] https://download.docker.com/linux/debian \ $(lsb_release -cs) \ stable" Install docker-ce. # apt-get update && apt-get -y install docker-ce Check docker version # docker -v Docker version 18.09.0, build 4d60db4 

उसके बाद, सभी नोड्स पर कुबेरनेट पैकेज स्थापित करें:

• kubeadm : क्लस्टर लोड करने के लिए कमांड।
• kubelet : एक घटक जो क्लस्टर में सभी कंप्यूटरों पर चलता है और चूल्हा और कंटेनरों को लॉन्च करने जैसी क्रियाएं करता है।
• kubectl : क्लस्टर के साथ संवाद करने के लिए कमांड लाइन का उपयोग करें।
• kubectl - at will; मैं अक्सर डिबगिंग के लिए कुछ कुबेरनेट कमांड चलाने के लिए इसे सभी नोड्स पर स्थापित करता हूं।

 # curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add - Add the Google repository # cat <<EOF >/etc/apt/sources.list.d/kubernetes.list deb https://apt.kubernetes.io/ kubernetes-xenial main EOF Update and install packages # apt-get update && apt-get install -y kubelet kubeadm kubectl Hold back packages # apt-mark hold kubelet kubeadm kubectl Check kubeadm version # kubeadm version kubeadm version: &version.Info{Major:"1", Minor:"13", GitVersion:"v1.13.1", GitCommit:"eec55b9dsfdfgdfgfgdfgdfgdf365bdd920", GitTreeState:"clean", BuildDate:"2018-12-13T10:36:44Z", GoVersion:"go1.11.2", Compiler:"gc", Platform:"linux/amd64"} 

कुबेदम और अन्य पैकेज स्थापित करने के बाद, स्वैप को अक्षम करना न भूलें।

 # swapoff -a # sed -i '/ swap / s/^/#/' /etc/fstab 

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

5. HA Etcd क्लस्टर कॉन्फ़िगर करें

इसलिए, तैयारी पूरी करने के बाद, हम कुबेरनेट समूह को कॉन्फ़िगर करेंगे। पहली ईंट HA Etcd क्लस्टर होगी, जिसे kubeadm टूल का उपयोग करके भी कॉन्फ़िगर किया गया है।

शुरू करने से पहले, सुनिश्चित करें कि सभी etc नोड्स 2379 और 2380 बंदरगाहों के माध्यम से संवाद करते हैं। इसके अलावा, आपको scp का उपयोग करने के लिए उनके बीच ssh एक्सेस को कॉन्फ़िगर करने की आवश्यकता है।

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

सभी etcd नोड्स पर, आपको क्यूबलेट यूनिट के लिए एक उच्च प्राथमिकता के साथ एक नई systemd विन्यास फाइल जोड़ने की जरूरत है:

 etcd-nodes# cat << EOF > /etc/systemd/system/kubelet.service.d/20-etcd-service-manager.conf [Service] ExecStart= ExecStart=/usr/bin/kubelet --address=127.0.0.1 --pod-manifest-path=/etc/kubernetes/manifests --allow-privileged=true Restart=always EOF etcd-nodes# systemctl daemon-reload etcd-nodes# systemctl restart kubelet 

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

 # Export all our etcd nodes IP's as variables etcd1# export HOST0=192.168.0.2 etcd1# export HOST1=192.168.0.3 etcd1# export HOST2=192.168.0.4 # Create temp directories to store files for all nodes etcd1# mkdir -p /tmp/${HOST0}/ /tmp/${HOST1}/ /tmp/${HOST2}/ etcd1# ETCDHOSTS=(${HOST0} ${HOST1} ${HOST2}) etcd1# NAMES=("infra0" "infra1" "infra2") etcd1# for i in "${!ETCDHOSTS[@]}"; do HOST=${ETCDHOSTS[$i]} NAME=${NAMES[$i]} cat << EOF > /tmp/${HOST}/kubeadmcfg.yaml apiVersion: "kubeadm.k8s.io/v1beta1" kind: ClusterConfiguration etcd: local: serverCertSANs: - "${HOST}" peerCertSANs: - "${HOST}" extraArgs: initial-cluster: ${NAMES[0]}=https://${ETCDHOSTS[0]}:2380,${NAMES[1]}=https://${ETCDHOSTS[1]}:2380,${NAMES[2]}=https://${ETCDHOSTS[2]}:2380 initial-cluster-state: new name: ${NAME} listen-peer-urls: https://${HOST}:2380 listen-client-urls: https://${HOST}:2379 advertise-client-urls: https://${HOST}:2379 initial-advertise-peer-urls: https://${HOST}:2380 EOF done 

अब कुबेदम का उपयोग करके मुख्य प्रमाणपत्र प्राधिकरण बनाएं

 etcd1# kubeadm init phase certs etcd-ca 

यह कमांड / etc / kubernetes / pki / etcd / निर्देशिका में दो ca.crt और ca.key फाइलें बनाएगा ।

 etcd1# ls /etc/kubernetes/pki/etcd/ ca.crt ca.key 

अब हम सभी वगैरह नोड्स के लिए सर्टिफिकेट तैयार करेंगे:

 ### Create certificates for the etcd3 node etcd1# kubeadm init phase certs etcd-server --config=/tmp/${HOST2}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-peer --config=/tmp/${HOST2}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-healthcheck-client --config=/tmp/${HOST2}/kubeadmcfg.yaml etcd1# kubeadm init phase certs apiserver-etcd-client --config=/tmp/${HOST2}/kubeadmcfg.yaml etcd1# cp -R /etc/kubernetes/pki /tmp/${HOST2}/ ### cleanup non-reusable certificates etcd1# find /etc/kubernetes/pki -not -name ca.crt -not -name ca.key -type f -delete ### Create certificates for the etcd2 node etcd1# kubeadm init phase certs etcd-server --config=/tmp/${HOST1}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-peer --config=/tmp/${HOST1}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-healthcheck-client --config=/tmp/${HOST1}/kubeadmcfg.yaml etcd1# kubeadm init phase certs apiserver-etcd-client --config=/tmp/${HOST1}/kubeadmcfg.yaml etcd1# cp -R /etc/kubernetes/pki /tmp/${HOST1}/ ### cleanup non-reusable certificates again etcd1# find /etc/kubernetes/pki -not -name ca.crt -not -name ca.key -type f -delete ### Create certificates for the this local node etcd1# kubeadm init phase certs etcd-server --config=/tmp/${HOST0}/kubeadmcfg.yaml etcd1 #kubeadm init phase certs etcd-peer --config=/tmp/${HOST0}/kubeadmcfg.yaml etcd1# kubeadm init phase certs etcd-healthcheck-client --config=/tmp/${HOST0}/kubeadmcfg.yaml etcd1# kubeadm init phase certs apiserver-etcd-client --config=/tmp/${HOST0}/kubeadmcfg.yaml # No need to move the certs because they are for this node # clean up certs that should not be copied off this host etcd1# find /tmp/${HOST2} -name ca.key -type f -delete etcd1# find /tmp/${HOST1} -name ca.key -type f -delete 

फिर kubeadm के प्रमाणपत्र और कॉन्फ़िगरेशन को नोड्स etcd2 और etcd3 पर कॉपी करें ।

पहले etcd1 पर ssh कीज़ की एक जोड़ी बनाएँ और सार्वजनिक भाग को etcd2 और 3 नोड्स में जोड़ें । इस उदाहरण में, सभी कमांड को उस उपयोगकर्ता की ओर से निष्पादित किया जाता है जो सिस्टम में सभी अधिकारों का मालिक है।

 etcd1# scp -r /tmp/${HOST1}/* ${HOST1}: etcd1# scp -r /tmp/${HOST2}/* ${HOST2}: ### login to the etcd2 or run this command remotely by ssh etcd2# cd /root etcd2# mv pki /etc/kubernetes/ ### login to the etcd3 or run this command remotely by ssh etcd3# cd /root etcd3# mv pki /etc/kubernetes/ 

Etcd क्लस्टर शुरू करने से पहले, सुनिश्चित करें कि सभी नोड्स पर फाइलें मौजूद हैं:

Etcd1 पर आवश्यक फाइलों की सूची:

 /tmp/192.168.0.2 └── kubeadmcfg.yaml --- /etc/kubernetes/pki ├── apiserver-etcd-client.crt ├── apiserver-etcd-client.key └── etcd ├── ca.crt ├── ca.key ├── healthcheck-client.crt ├── healthcheck-client.key ├── peer.crt ├── peer.key ├── server.crt └── server.key 

Etcd2 नोड के लिए , यह है:

 /root └── kubeadmcfg.yaml --- /etc/kubernetes/pki ├── apiserver-etcd-client.crt ├── apiserver-etcd-client.key └── etcd ├── ca.crt ├── healthcheck-client.crt ├── healthcheck-client.key ├── peer.crt ├── peer.key ├── server.crt └── server.key 

और अंतिम नोड etcd3 है :

 /root └── kubeadmcfg.yaml --- /etc/kubernetes/pki ├── apiserver-etcd-client.crt ├── apiserver-etcd-client.key └── etcd ├── ca.crt ├── healthcheck-client.crt ├── healthcheck-client.key ├── peer.crt ├── peer.key ├── server.crt └── server.key 

जब सभी प्रमाण पत्र और कॉन्फ़िगरेशन जगह में होते हैं, तो हम मैनिफ़ेस्ट बनाते हैं। प्रत्येक नोड पर, kubeadm कमांड चलाएं - etc क्लस्टर के लिए एक स्थैतिक प्रकट करने के लिए:

 etcd1# kubeadm init phase etcd local --config=/tmp/192.168.0.2/kubeadmcfg.yaml etcd1# kubeadm init phase etcd local --config=/root/kubeadmcfg.yaml etcd1# kubeadm init phase etcd local --config=/root/kubeadmcfg.yaml 

अब क्लस्टर etcd - सिद्धांत रूप में - कॉन्फ़िगर और स्वस्थ है। निम्नलिखित कमांड को etcd1 नोड पर चलाकर सत्यापित करें:

 etcd1# docker run --rm -it \ --net host \ -v /etc/kubernetes:/etc/kubernetes quay.io/coreos/etcd:v3.2.24 etcdctl \ --cert-file /etc/kubernetes/pki/etcd/peer.crt \ --key-file /etc/kubernetes/pki/etcd/peer.key \ --ca-file /etc/kubernetes/pki/etcd/ca.crt \ --endpoints https://192.168.0.2:2379 cluster-health ### status output member 37245675bd09ddf3 is healthy: got healthy result from https://192.168.0.3:2379 member 532d748291f0be51 is healthy: got healthy result from https://192.168.0.4:2379 member 59c53f494c20e8eb is healthy: got healthy result from https://192.168.0.2:2379 cluster is healthy 

कॉर्ड क्लस्टर बढ़ गया है, इसलिए आगे बढ़ें।

6. मास्टर और काम नोड्स को कॉन्फ़िगर करना

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

 etcd1# scp /etc/kubernetes/pki/etcd/ca.crt 192.168.0.5: etcd1# scp /etc/kubernetes/pki/apiserver-etcd-client.crt 192.168.0.5: etcd1# scp /etc/kubernetes/pki/apiserver-etcd-client.key 192.168.0.5: 

फिर मास्टर नोड मास्टर 1 पर जाएं और निम्न सामग्रियों के साथ कुबेदम-config.yaml फ़ाइल बनाएँ:

 master1# cd /root && vi kubeadm-config.yaml apiVersion: kubeadm.k8s.io/v1beta1 kind: ClusterConfiguration kubernetesVersion: stable apiServer: certSANs: - "192.168.0.1" controlPlaneEndpoint: "192.168.0.1:6443" etcd: external: endpoints: - https://192.168.0.2:2379 - https://192.168.0.3:2379 - https://192.168.0.4:2379 caFile: /etc/kubernetes/pki/etcd/ca.crt certFile: /etc/kubernetes/pki/apiserver-etcd-client.crt keyFile: /etc/kubernetes/pki/apiserver-etcd-client.key 

सेटिंग के विवरण के अनुसार पहले से कॉपी किए गए प्रमाणपत्र और कुंजी को उचित निर्देशिका में कुंजी पर ले जाएं।

 master1# mkdir -p /etc/kubernetes/pki/etcd/ master1# cp /root/ca.crt /etc/kubernetes/pki/etcd/ master1# cp /root/apiserver-etcd-client.crt /etc/kubernetes/pki/ master1# cp /root/apiserver-etcd-client.key /etc/kubernetes/pki/ 

पहला मास्टर नोड बनाने के लिए, करें:

 master1# kubeadm init --config kubeadm-config.yaml 

यदि सभी पिछले चरण सही ढंग से पूरे हो गए हैं, तो आप निम्नलिखित देखेंगे:

 You can now join any number of machines by running the following on each node as root: kubeadm join 192.168.0.1:6443 --token aasuvd.kw8m18m5fy2ot387 --discovery-token-ca-cert-hash sha256:dcbaeed8d1478291add0294553b6b90b453780e546d06162c71d515b494177a6 

इस kubeadm initialization आउटपुट को किसी भी टेक्स्ट फ़ाइल में कॉपी करें, हम भविष्य में इस टोकन का उपयोग करेंगे जब हम दूसरे मास्टर और काम करने वाले नोड्स को हमारे क्लस्टर में संलग्न करेंगे।

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

पहले मास्टर नोड पर बुनाई नेटवर्क प्लगइन स्थापित करना:

 master1# kubectl --kubeconfig /etc/kubernetes/admin.conf apply -f "https://cloud.weave.works/k8s/net?k8s-version=$(kubectl version | base64 | tr -d '\n')" The connection to the server localhost:8080 was refused - did you specify the right host or port? serviceaccount/weave-net created clusterrole.rbac.authorization.k8s.io/weave-net created clusterrolebinding.rbac.authorization.k8s.io/weave-net created role.rbac.authorization.k8s.io/weave-net created rolebinding.rbac.authorization.k8s.io/weave-net created daemonset.extensions/weave-net created 

एक क्षण रुकें, और फिर निम्न कमांड दर्ज करें कि यह सुनिश्चित करने के लिए कि घटक चूल्हा शुरू होता है:

 master1# kubectl --kubeconfig /etc/kubernetes/admin.conf get pod -n kube-system -w NAME READY STATUS RESTARTS AGE coredns-86c58d9df4-d7qfw 1/1 Running 0 6m25s coredns-86c58d9df4-xj98p 1/1 Running 0 6m25s kube-apiserver-master1 1/1 Running 0 5m22s kube-controller-manager-master1 1/1 Running 0 5m41s kube-proxy-8ncqw 1/1 Running 0 6m25s kube-scheduler-master1 1/1 Running 0 5m25s weave-net-lvwrp 2/2 Running 0 78s 

• पहले नोड के प्रारंभ के बाद ही नियंत्रण विमान के नए नोड्स संलग्न करने की सिफारिश की जाती है।

क्लस्टर स्थिति की जाँच करने के लिए, करें:

 master1# kubectl --kubeconfig /etc/kubernetes/admin.conf get nodes NAME STATUS ROLES AGE VERSION master1 Ready master 11m v1.13.1 

वाह! पहला मास्टर नोड गुलाब। अब यह तैयार है, और हम कुबेरनेट क्लस्टर बनाने का काम पूरा करेंगे - हम एक दूसरे मास्टर नोड और काम करने वाले नोड्स को जोड़ेंगे।
दूसरा मास्टर नोड जोड़ने के लिए, मास्टर 1 पर एक ssh कुंजी बनाएं और सार्वजनिक भाग को मास्टर 2 में जोड़ें । एक परीक्षण लॉगिन करें, और फिर पहले मास्टर नोड से दूसरे तक कुछ फ़ाइलों की प्रतिलिपि बनाएँ:

 master1# scp /etc/kubernetes/pki/ca.crt 192.168.0.6: master1# scp /etc/kubernetes/pki/ca.key 192.168.0.6: master1# scp /etc/kubernetes/pki/sa.key 192.168.0.6: master1# scp /etc/kubernetes/pki/sa.pub 192.168.0.6: master1# scp /etc/kubernetes/pki/front-proxy-ca.crt @192.168.0.6: master1# scp /etc/kubernetes/pki/front-proxy-ca.key @192.168.0.6: master1# scp /etc/kubernetes/pki/apiserver-etcd-client.crt @192.168.0.6: master1# scp /etc/kubernetes/pki/apiserver-etcd-client.key @192.168.0.6: master1# scp /etc/kubernetes/pki/etcd/ca.crt 192.168.0.6:etcd-ca.crt master1# scp /etc/kubernetes/admin.conf 192.168.0.6: ### Check that files was copied well master2# ls /root admin.conf ca.crt ca.key etcd-ca.crt front-proxy-ca.crt front-proxy-ca.key sa.key sa.pub 

दूसरे मास्टर नोड पर, पहले से कॉपी किए गए प्रमाणपत्र और कुंजियों को उचित निर्देशिका में ले जाएं:

 master2# mkdir -p /etc/kubernetes/pki/etcd mv /root/ca.crt /etc/kubernetes/pki/ mv /root/ca.key /etc/kubernetes/pki/ mv /root/sa.pub /etc/kubernetes/pki/ mv /root/sa.key /etc/kubernetes/pki/ mv /root/apiserver-etcd-client.crt /etc/kubernetes/pki/ mv /root/apiserver-etcd-client.key /etc/kubernetes/pki/ mv /root/front-proxy-ca.crt /etc/kubernetes/pki/ mv /root/front-proxy-ca.key /etc/kubernetes/pki/ mv /root/etcd-ca.crt /etc/kubernetes/pki/etcd/ca.crt mv /root/admin.conf /etc/kubernetes/admin.conf 

क्लस्टर के लिए दूसरा मास्टर नोड कनेक्ट करें। ऐसा करने के लिए, आपको कनेक्शन कमांड के आउटपुट की आवश्यकता है, जिसे पहले नोड पर kubeadm init द्वारा पास किया गया था।

मास्टर नोड मास्टर 2 चलाएँ:

 master2# kubeadm join 192.168.0.1:6443 --token aasuvd.kw8m18m5fy2ot387 --discovery-token-ca-cert-hash sha256:dcbaeed8d1478291add0294553b6b90b453780e546d06162c71d515b494177a6 --experimental-control-plane 

• आपको --experimental-control-plane फ्लैग जोड़ने की जरूरत है। यह एक क्लस्टर में मास्टर डेटा के अनुलग्नक को स्वचालित करता है। इस ध्वज के बिना, सामान्य रूप से काम करने वाला नोड बस जोड़ा जाएगा।

थोड़ा इंतजार करें जब तक कि नोड क्लस्टर में शामिल नहीं हो जाता है, और क्लस्टर की नई स्थिति की जांच करें:

 master1# kubectl --kubeconfig /etc/kubernetes/admin.conf get nodes NAME STATUS ROLES AGE VERSION master1 Ready master 32m v1.13.1 master2 Ready master 46s v1.13.1 

यह भी सुनिश्चित करें कि सभी मास्टर नोड्स से सभी पॉड सामान्य रूप से शुरू किए गए हैं:

 master1# kubectl — kubeconfig /etc/kubernetes/admin.conf get pod -n kube-system -w NAME READY STATUS RESTARTS AGE coredns-86c58d9df4-d7qfw 1/1 Running 0 46m coredns-86c58d9df4-xj98p 1/1 Running 0 46m kube-apiserver-master1 1/1 Running 0 45m kube-apiserver-master2 1/1 Running 0 15m kube-controller-manager-master1 1/1 Running 0 45m kube-controller-manager-master2 1/1 Running 0 15m kube-proxy-8ncqw 1/1 Running 0 46m kube-proxy-px5dt 1/1 Running 0 15m kube-scheduler-master1 1/1 Running 0 45m kube-scheduler-master2 1/1 Running 0 15m weave-net-ksvxz 2/2 Running 1 15m weave-net-lvwrp 2/2 Running 0 41m 

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

काम कर रहे नोड्स दर्ज करें और kubeadm को --experimental-control-plane फ्लैग के बिना कमांड में शामिल करें।

 worker1-3# kubeadm join 192.168.0.1:6443 --token aasuvd.kw8m18m5fy2ot387 --discovery-token-ca-cert-hash sha256:dcbaeed8d1478291add0294553b6b90b453780e546d06162c71d515b494177a6 

क्लस्टर स्थिति को फिर से जांचें:

 master1# kubectl --kubeconfig /etc/kubernetes/admin.conf get nodes NAME STATUS ROLES AGE VERSION master1 Ready master 1h30m v1.13.1 master2 Ready master 1h59m v1.13.1 worker1 Ready <none> 1h8m v1.13.1 worker2 Ready <none> 1h8m v1.13.1 worker3 Ready <none> 1h7m v1.13.1 

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

7. दूरस्थ क्लस्टर प्रबंधन को कॉन्फ़िगर करना

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

इस सर्वर में लॉग इन करें और चलाएं:

 Add the Google repository key control# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add - Add the Google repository control# cat <<EOF >/etc/apt/sources.list.d/kubernetes.list deb https://apt.kubernetes.io/ kubernetes-xenial main EOF Update and install kubectl control# apt-get update && apt-get install -y kubectl In your user home dir create control# mkdir ~/.kube Take the Kubernetes admin.conf from the master1 node control# scp 192.168.0.5:/etc/kubernetes/admin.conf ~/.kube/config Check that we can send commands to our cluster control# kubectl get nodes NAME STATUS ROLES AGE VERSION master1 Ready master 6h58m v1.13.1 master2 Ready master 6h27m v1.13.1 worker1 Ready <none> 5h36m v1.13.1 worker2 Ready <none> 5h36m v1.13.1 worker3 Ready <none> 5h36m v1.13.1 

ठीक है, अब हमारे क्लस्टर में एक परीक्षण चलाएं और जांचें कि यह कैसे काम करता है।

 control# kubectl create deployment nginx --image=nginx deployment.apps/nginx created control# kubectl get pods NAME READY STATUS RESTARTS AGE nginx-5c7588df-6pvgr 1/1 Running 0 52s 

बधाई! आपने अभी कुबेरनेट्स की तैनाती की है। और इसका मतलब है कि आपका नया हा क्लस्टर तैयार है। वास्तव में, कुबेदम का उपयोग करके कुबेरनेट्स क्लस्टर स्थापित करने की प्रक्रिया काफी सरल और तेज है।

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

अंतभाषण

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

आज के लिए बस इतना ही। सौभाग्य है