🥇क्लस्टर के लिए अपना खुद का ऑटोस्केलर कैसे बनाएं

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

इस पोस्ट में हम आपको बताएंगे कि कैसे हमने क्लाउड का उपयोग करके अपना स्वयं का ऑटोस्केलर लिखकर असमान क्लस्टर लोडिंग की समस्या को हल किया Mail.ru क्लाउड सॉल्यूशंस.

समस्या

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

समाधान #1 एक ऐसा क्लस्टर रखना है जो चरम भार का सामना करेगा, लेकिन बाकी समय निष्क्रिय रहेगा।

समाधान #2 एक छोटा क्लस्टर रखना है, जिसमें आप कक्षाओं से पहले और पीक लोड के दौरान मैन्युअल रूप से नोड्स जोड़ते हैं।

समाधान #3 एक छोटा क्लस्टर रखना और एक ऑटोस्केलर लिखना है जो क्लस्टर के वर्तमान लोड की निगरानी करेगा और, विभिन्न एपीआई का उपयोग करके, क्लस्टर से नोड्स जोड़ और हटा देगा।

इस पोस्ट में हम समाधान #3 के बारे में बात करेंगे। यह ऑटोस्केलर आंतरिक कारकों के बजाय बाहरी कारकों पर अत्यधिक निर्भर है, और प्रदाता अक्सर इसे प्रदान नहीं करते हैं। हम Mail.ru क्लाउड सॉल्यूशंस क्लाउड इंफ्रास्ट्रक्चर का उपयोग करते हैं और MCS API का उपयोग करके एक ऑटोस्केलर लिखते हैं। और चूंकि हम डेटा के साथ काम करना सिखाते हैं, इसलिए हमने यह दिखाने का निर्णय लिया कि आप अपने उद्देश्यों के लिए एक समान ऑटोस्केलर कैसे लिख सकते हैं और इसे अपने क्लाउड के साथ उपयोग कर सकते हैं

.. पूर्वापेक्षाएँ

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

आपके नोड्स को शीघ्रता से जोड़ने और हटाने के लिए, आपके पास नोड्स के बीच भूमिकाओं का एक निश्चित वितरण होना चाहिए।

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

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

तो, हमारा ऑटोस्केलर पायथन 3 में लिखा गया है, क्लस्टर सेवाओं, उपयोगों को प्रबंधित करने के लिए अंबारी एपीआई का उपयोग करता है Mail.ru क्लाउड सॉल्यूशंस से एपीआई (एमसीएस) मशीनों को शुरू करने और रोकने के लिए।

समाधान वास्तुकला

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

आइए अब पहली दो फाइलों के अंदर कोड के टुकड़ों को देखें।

1. Autoscaler.py मॉड्यूल

अंबारी कक्षा

क्लास युक्त कोड का एक टुकड़ा इस तरह दिखता है Ambari:

class Ambari:
    def __init__(self, ambari_url, cluster_name, headers, auth):
        self.ambari_url = ambari_url
        self.cluster_name = cluster_name
        self.headers = headers
        self.auth = auth

    def stop_all_services(self, hostname):
        url = self.ambari_url + self.cluster_name + '/hosts/' + hostname + '/host_components/'
        url2 = self.ambari_url + self.cluster_name + '/hosts/' + hostname
        req0 = requests.get(url2, headers=self.headers, auth=self.auth)
        services = req0.json()['host_components']
        services_list = list(map(lambda x: x['HostRoles']['component_name'], services))
        data = {
            "RequestInfo": {
                "context":"Stop All Host Components",
                "operation_level": {
                    "level":"HOST",
                    "cluster_name": self.cluster_name,
                    "host_names": hostname
                },
                "query":"HostRoles/component_name.in({0})".format(",".join(services_list))
            },
            "Body": {
                "HostRoles": {
                    "state":"INSTALLED"
                }
            }
        }
        req = requests.put(url, data=json.dumps(data), headers=self.headers, auth=self.auth)
        if req.status_code in [200, 201, 202]:
            message = 'Request accepted'
        else:
            message = req.status_code
        return message

ऊपर, उदाहरण के तौर पर, आप फ़ंक्शन के कार्यान्वयन को देख सकते हैं stop_all_services, जो वांछित क्लस्टर नोड पर सभी सेवाओं को रोक देता है।

कक्षा के प्रवेश द्वार पर Ambari आप निकलिए:

ambari_url, उदाहरण के लिए, जैसे 'http://localhost:8080/api/v1/clusters/',
cluster_name - अंबारी में आपके क्लस्टर का नाम,
headers = {'X-Requested-By': 'ambari'}
और अंदर auth अंबारी के लिए आपका उपयोगकर्ता नाम और पासवर्ड यहां दिया गया है: auth = ('login', 'password').

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

क्लास एम.सी.एस

क्लास युक्त कोड का एक टुकड़ा इस तरह दिखता है Mcs:

class Mcs:
    def __init__(self, id1, id2, password):
        self.id1 = id1
        self.id2 = id2
        self.password = password
        self.mcs_host = 'https://infra.mail.ru:8774/v2.1'

    def vm_turn_on(self, hostname):
        self.token = self.get_mcs_token()
        host = self.hostname_to_vmname(hostname)
        vm_id = self.get_vm_id(host)
        mcs_url1 = self.mcs_host + '/servers/' + self.vm_id + '/action'
        headers = {
            'X-Auth-Token': '{0}'.format(self.token),
            'Content-Type': 'application/json'
        }
        data = {'os-start' : 'null'}
        mcs = requests.post(mcs_url1, data=json.dumps(data), headers=headers)
        return mcs.status_code

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

टोकन प्राप्त करने का कार्य इस प्रकार दिखता है:

def get_mcs_token(self):
        url = 'https://infra.mail.ru:35357/v3/auth/tokens?nocatalog'
        headers = {'Content-Type': 'application/json'}
        data = {
            'auth': {
                'identity': {
                    'methods': ['password'],
                    'password': {
                        'user': {
                            'id': self.id1,
                            'password': self.password
                        }
                    }
                },
                'scope': {
                    'project': {
                        'id': self.id2
                    }
                }
            }
        }
        params = (('nocatalog', ''),)
        req = requests.post(url, data=json.dumps(data), headers=headers, params=params)
        self.token = req.headers['X-Subject-Token']
        return self.token

ऑटोस्केलर क्लास

इस वर्ग में ऑपरेटिंग लॉजिक से संबंधित फ़ंक्शन शामिल हैं।

इस वर्ग के लिए कोड का एक टुकड़ा इस प्रकार दिखता है:

class Autoscaler:
    def __init__(self, ambari, mcs, scaling_hosts, yarn_ram_per_node, yarn_cpu_per_node):
        self.scaling_hosts = scaling_hosts
        self.ambari = ambari
        self.mcs = mcs
        self.q_ram = deque()
        self.q_cpu = deque()
        self.num = 0
        self.yarn_ram_per_node = yarn_ram_per_node
        self.yarn_cpu_per_node = yarn_cpu_per_node

    def scale_down(self, hostname):
        flag1 = flag2 = flag3 = flag4 = flag5 = False
        if hostname in self.scaling_hosts:
            while True:
                time.sleep(5)
                status1 = self.ambari.decommission_nodemanager(hostname)
                if status1 == 'Request accepted' or status1 == 500:
                    flag1 = True
                    logging.info('Decomission request accepted: {0}'.format(flag1))
                    break
            while True:
                time.sleep(5)
                status3 = self.ambari.check_service(hostname, 'NODEMANAGER')
                if status3 == 'INSTALLED':
                    flag3 = True
                    logging.info('Nodemaneger decommissioned: {0}'.format(flag3))
                    break
            while True:
                time.sleep(5)
                status2 = self.ambari.maintenance_on(hostname)
                if status2 == 'Request accepted' or status2 == 500:
                    flag2 = True
                    logging.info('Maintenance request accepted: {0}'.format(flag2))
                    break
            while True:
                time.sleep(5)
                status4 = self.ambari.check_maintenance(hostname, 'NODEMANAGER')
                if status4 == 'ON' or status4 == 'IMPLIED_FROM_HOST':
                    flag4 = True
                    self.ambari.stop_all_services(hostname)
                    logging.info('Maintenance is on: {0}'.format(flag4))
                    logging.info('Stopping services')
                    break
            time.sleep(90)
            status5 = self.mcs.vm_turn_off(hostname)
            while True:
                time.sleep(5)
                status5 = self.mcs.get_vm_info(hostname)['server']['status']
                if status5 == 'SHUTOFF':
                    flag5 = True
                    logging.info('VM is turned off: {0}'.format(flag5))
                    break
            if flag1 and flag2 and flag3 and flag4 and flag5:
                message = 'Success'
                logging.info('Scale-down finished')
                logging.info('Cooldown period has started. Wait for several minutes')
        return message

हम प्रवेश के लिए कक्षाएं स्वीकार करते हैं। Ambari и Mcs, नोड्स की एक सूची जिन्हें स्केलिंग के लिए अनुमति दी गई है, साथ ही नोड कॉन्फ़िगरेशन पैरामीटर: YARN में नोड को आवंटित मेमोरी और सीपीयू। 2 आंतरिक पैरामीटर q_ram, q_cpu भी हैं, जो कतार हैं। उनका उपयोग करके, हम वर्तमान क्लस्टर लोड के मूल्यों को संग्रहीत करते हैं। यदि हम देखते हैं कि पिछले 5 मिनट में लोड में लगातार वृद्धि हुई है, तो हम निर्णय लेते हैं कि हमें क्लस्टर में +1 नोड जोड़ने की आवश्यकता है। क्लस्टर अल्पउपयोग स्थिति के लिए भी यही सच है।

उपरोक्त कोड एक फ़ंक्शन का उदाहरण है जो एक मशीन को क्लस्टर से निकालता है और क्लाउड में रोकता है। सबसे पहले डीकमीशनिंग होती है YARN Nodemanager, फिर मोड चालू हो जाता है Maintenance, फिर हम मशीन पर सभी सेवाओं को रोक देते हैं और क्लाउड में वर्चुअल मशीन को बंद कर देते हैं।

2. स्क्रिप्ट ऑब्जर्वर.py

वहां से नमूना कोड:

if scaler.assert_up(config.scale_up_thresholds) == True:
        hostname = cloud.get_vm_to_up(config.scaling_hosts)
        if hostname != None:
            status1 = scaler.scale_up(hostname)
            if status1 == 'Success':
                text = {"text": "{0} has been successfully scaled-up".format(hostname)}
                post = {"text": "{0}".format(text)}
                json_data = json.dumps(post)
                req = requests.post(webhook, data=json_data.encode('ascii'), headers={'Content-Type': 'application/json'})
                time.sleep(config.cooldown_period*60)

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

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

निष्कर्ष

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

स्रोत: www.habr.com

क्लस्टर के लिए अपना खुद का ऑटोस्केलर कैसे बनाएं