ਇੱਕ ਕਲੱਸਟਰ ਲਈ ਆਪਣਾ ਆਟੋਸਕੇਲਰ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ

ਸਤ ਸ੍ਰੀ ਅਕਾਲ! ਅਸੀਂ ਲੋਕਾਂ ਨੂੰ ਵੱਡੇ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸਿਖਲਾਈ ਦਿੰਦੇ ਹਾਂ। ਇਸ ਦੇ ਆਪਣੇ ਕਲੱਸਟਰ ਤੋਂ ਬਿਨਾਂ ਵੱਡੇ ਡੇਟਾ 'ਤੇ ਵਿਦਿਅਕ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਲਪਨਾ ਕਰਨਾ ਅਸੰਭਵ ਹੈ, ਜਿਸ 'ਤੇ ਸਾਰੇ ਭਾਗੀਦਾਰ ਇਕੱਠੇ ਕੰਮ ਕਰਦੇ ਹਨ. ਇਸ ਕਾਰਨ ਕਰਕੇ, ਸਾਡੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਹਮੇਸ਼ਾ ਇਹ ਹੁੰਦਾ ਹੈ 🙂 ਅਸੀਂ ਇਸਦੀ ਸੰਰਚਨਾ, ਟਿਊਨਿੰਗ ਅਤੇ ਪ੍ਰਸ਼ਾਸਨ ਵਿੱਚ ਰੁੱਝੇ ਹੋਏ ਹਾਂ, ਅਤੇ ਲੋਕ ਸਿੱਧੇ MapReduce ਨੌਕਰੀਆਂ ਨੂੰ ਉੱਥੇ ਲਾਂਚ ਕਰਦੇ ਹਨ ਅਤੇ ਸਪਾਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।

ਇਸ ਪੋਸਟ ਵਿੱਚ ਅਸੀਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗੇ ਕਿ ਅਸੀਂ ਕਲਾਉਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣਾ ਆਟੋਸਕੇਲਰ ਲਿਖ ਕੇ ਅਸਮਾਨ ਕਲੱਸਟਰ ਲੋਡਿੰਗ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਕਿਵੇਂ ਹੱਲ ਕੀਤਾ ਹੈ। Mail.ru ਕਲਾਉਡ ਹੱਲ.

ਸਮੱਸਿਆ

ਸਾਡਾ ਕਲੱਸਟਰ ਇੱਕ ਆਮ ਮੋਡ ਵਿੱਚ ਨਹੀਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਨਿਪਟਾਰਾ ਬਹੁਤ ਅਸਮਾਨ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਪ੍ਰੈਕਟੀਕਲ ਕਲਾਸਾਂ ਹੁੰਦੀਆਂ ਹਨ, ਜਦੋਂ ਸਾਰੇ 30 ਲੋਕ ਅਤੇ ਇੱਕ ਅਧਿਆਪਕ ਕਲੱਸਟਰ ਵਿੱਚ ਜਾਂਦੇ ਹਨ ਅਤੇ ਇਸਨੂੰ ਵਰਤਣਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਨ। ਜਾਂ ਦੁਬਾਰਾ, ਡੈੱਡਲਾਈਨ ਤੋਂ ਪਹਿਲਾਂ ਦੇ ਦਿਨ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਲੋਡ ਬਹੁਤ ਵਧ ਜਾਂਦਾ ਹੈ. ਬਾਕੀ ਸਮਾਂ ਕਲੱਸਟਰ ਅੰਡਰਲੋਡ ਮੋਡ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ।

ਹੱਲ #1 ਇੱਕ ਕਲੱਸਟਰ ਰੱਖਣਾ ਹੈ ਜੋ ਪੀਕ ਲੋਡ ਦਾ ਸਾਮ੍ਹਣਾ ਕਰੇਗਾ, ਪਰ ਬਾਕੀ ਸਮੇਂ ਵਿੱਚ ਵਿਹਲਾ ਰਹੇਗਾ।

ਹੱਲ #2 ਇੱਕ ਛੋਟਾ ਕਲੱਸਟਰ ਰੱਖਣਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਕਲਾਸਾਂ ਤੋਂ ਪਹਿਲਾਂ ਅਤੇ ਪੀਕ ਲੋਡ ਦੌਰਾਨ ਹੱਥੀਂ ਨੋਡ ਜੋੜਦੇ ਹੋ।

ਹੱਲ #3 ਇੱਕ ਛੋਟਾ ਕਲੱਸਟਰ ਰੱਖਣਾ ਹੈ ਅਤੇ ਇੱਕ ਆਟੋਸਕੇਲਰ ਲਿਖਣਾ ਹੈ ਜੋ ਕਲੱਸਟਰ ਦੇ ਮੌਜੂਦਾ ਲੋਡ ਦੀ ਨਿਗਰਾਨੀ ਕਰੇਗਾ ਅਤੇ, ਵੱਖ-ਵੱਖ API ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਕਲੱਸਟਰ ਤੋਂ ਨੋਡਾਂ ਨੂੰ ਜੋੜਨਾ ਅਤੇ ਹਟਾਉਣਾ ਹੈ।

ਇਸ ਪੋਸਟ ਵਿੱਚ ਅਸੀਂ ਹੱਲ #3 ਬਾਰੇ ਗੱਲ ਕਰਾਂਗੇ। ਇਹ ਆਟੋਸਕੇਲਰ ਅੰਦਰੂਨੀ ਕਾਰਕਾਂ ਦੀ ਬਜਾਏ ਬਾਹਰੀ ਕਾਰਕਾਂ 'ਤੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਿਰਭਰ ਹੈ, ਅਤੇ ਪ੍ਰਦਾਤਾ ਅਕਸਰ ਇਸਨੂੰ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰਦੇ ਹਨ। ਅਸੀਂ Mail.ru Cloud Solutions ਕਲਾਉਡ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਅਤੇ MCS API ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਆਟੋਸਕੇਲਰ ਲਿਖਿਆ ਹੈ। ਅਤੇ ਕਿਉਂਕਿ ਅਸੀਂ ਸਿਖਾਉਂਦੇ ਹਾਂ ਕਿ ਡੇਟਾ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ, ਅਸੀਂ ਇਹ ਦਿਖਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ ਕਿ ਤੁਸੀਂ ਆਪਣੇ ਖੁਦ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ ਇੱਕ ਸਮਾਨ ਆਟੋਸਕੇਲਰ ਕਿਵੇਂ ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਆਪਣੇ ਕਲਾਉਡ ਨਾਲ ਵਰਤ ਸਕਦੇ ਹੋ।

ਪੂਰਿ-ਲੋੜਾਂ

ਪਹਿਲਾਂ, ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਹੈਡੂਪ ਕਲੱਸਟਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ HDP ਵੰਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।

ਤੁਹਾਡੇ ਨੋਡਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਜੋੜਨ ਅਤੇ ਹਟਾਏ ਜਾਣ ਲਈ, ਤੁਹਾਡੇ ਕੋਲ ਨੋਡਾਂ ਵਿੱਚ ਭੂਮਿਕਾਵਾਂ ਦੀ ਇੱਕ ਖਾਸ ਵੰਡ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।

1. ਮਾਸਟਰ ਨੋਡ. ਖੈਰ, ਖਾਸ ਤੌਰ 'ਤੇ ਕੁਝ ਵੀ ਸਮਝਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ: ਕਲੱਸਟਰ ਦਾ ਮੁੱਖ ਨੋਡ, ਜਿਸ 'ਤੇ, ਉਦਾਹਰਨ ਲਈ, ਸਪਾਰਕ ਡਰਾਈਵਰ ਲਾਂਚ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੇ ਤੁਸੀਂ ਇੰਟਰਐਕਟਿਵ ਮੋਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ.
2. ਮਿਤੀ ਨੋਡ. ਇਹ ਉਹ ਨੋਡ ਹੈ ਜਿਸ 'ਤੇ ਤੁਸੀਂ HDFS 'ਤੇ ਡਾਟਾ ਸਟੋਰ ਕਰਦੇ ਹੋ ਅਤੇ ਜਿੱਥੇ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
3. ਕੰਪਿਊਟਿੰਗ ਨੋਡ. ਇਹ ਇੱਕ ਨੋਡ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ HDFS 'ਤੇ ਕੁਝ ਵੀ ਸਟੋਰ ਨਹੀਂ ਕਰਦੇ, ਪਰ ਜਿੱਥੇ ਗਣਨਾ ਹੁੰਦੀ ਹੈ।

ਮਹੱਤਵਪੂਰਨ ਬਿੰਦੂ. ਤੀਜੀ ਕਿਸਮ ਦੇ ਨੋਡਾਂ ਦੇ ਕਾਰਨ ਆਟੋਸਕੇਲਿੰਗ ਹੋਵੇਗੀ। ਜੇਕਰ ਤੁਸੀਂ ਦੂਜੀ ਕਿਸਮ ਦੇ ਨੋਡਾਂ ਨੂੰ ਲੈਣਾ ਅਤੇ ਜੋੜਨਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ, ਤਾਂ ਜਵਾਬ ਦੀ ਗਤੀ ਬਹੁਤ ਘੱਟ ਹੋਵੇਗੀ - ਡੀਕਮਿਸ਼ਨਿੰਗ ਅਤੇ ਰੀਕਮਿਟਿੰਗ ਤੁਹਾਡੇ ਕਲੱਸਟਰ 'ਤੇ ਘੰਟੇ ਲਵੇਗੀ। ਇਹ, ਬੇਸ਼ਕ, ਉਹ ਨਹੀਂ ਹੈ ਜੋ ਤੁਸੀਂ ਆਟੋਸਕੇਲਿੰਗ ਤੋਂ ਉਮੀਦ ਕਰਦੇ ਹੋ। ਭਾਵ, ਅਸੀਂ ਪਹਿਲੀ ਅਤੇ ਦੂਜੀ ਕਿਸਮ ਦੇ ਨੋਡਾਂ ਨੂੰ ਨਹੀਂ ਛੂਹਦੇ. ਉਹ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਵਿਹਾਰਕ ਕਲੱਸਟਰ ਦੀ ਨੁਮਾਇੰਦਗੀ ਕਰਨਗੇ ਜੋ ਪ੍ਰੋਗਰਾਮ ਦੇ ਪੂਰੇ ਸਮੇਂ ਦੌਰਾਨ ਮੌਜੂਦ ਰਹੇਗਾ।

ਇਸ ਲਈ, ਸਾਡਾ ਆਟੋਸਕੇਲਰ ਪਾਈਥਨ 3 ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ, ਕਲੱਸਟਰ ਸੇਵਾਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਅੰਬਰੀ API ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਵਰਤਦਾ ਹੈ Mail.ru ਕਲਾਉਡ ਹੱਲ ਤੋਂ API (MCS) ਮਸ਼ੀਨਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਅਤੇ ਬੰਦ ਕਰਨ ਲਈ।

ਹੱਲ ਆਰਕੀਟੈਕਚਰ

1. ਮੋਡੀuleਲ autoscaler.py. ਇਸ ਵਿੱਚ ਤਿੰਨ ਸ਼੍ਰੇਣੀਆਂ ਹਨ: 1) ਅੰਬਰੀ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ, 2) MCS ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ, 3) ਆਟੋਸਕੇਲਰ ਦੇ ਤਰਕ ਨਾਲ ਸਿੱਧੇ ਸਬੰਧਤ ਫੰਕਸ਼ਨ।
2. ਸਕ੍ਰਿਪਟ observer.py. ਅਸਲ ਵਿੱਚ ਇਸ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਨਿਯਮ ਹੁੰਦੇ ਹਨ: ਆਟੋਸਕੇਲਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਦੋਂ ਅਤੇ ਕਿਹੜੇ ਪਲਾਂ 'ਤੇ ਕਾਲ ਕਰਨਾ ਹੈ।
3. ਸੰਰਚਨਾ ਫਾਇਲ 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, ਉਦਾਹਰਨ ਲਈ, like 'http://localhost:8080/api/v1/clusters/',
• cluster_name - ਅੰਬਰੀ ਵਿੱਚ ਤੁਹਾਡੇ ਕਲੱਸਟਰ ਦਾ ਨਾਮ,
• headers = {'X-Requested-By': 'ambari'}
• ਅਤੇ ਅੰਦਰ auth ਅੰਬਰੀ ਲਈ ਤੁਹਾਡਾ ਲੌਗਇਨ ਅਤੇ ਪਾਸਵਰਡ ਇਹ ਹੈ: auth = ('login', 'password').

ਫੰਕਸ਼ਨ ਆਪਣੇ ਆਪ ਵਿੱਚ ਅੰਬਰੀ ਨੂੰ REST API ਦੁਆਰਾ ਦੋ ਕਾਲਾਂ ਤੋਂ ਵੱਧ ਕੁਝ ਨਹੀਂ ਹੈ। ਤਰਕਪੂਰਨ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਅਸੀਂ ਪਹਿਲਾਂ ਇੱਕ ਨੋਡ 'ਤੇ ਚੱਲ ਰਹੀਆਂ ਸੇਵਾਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਫਿਰ ਇੱਕ ਦਿੱਤੇ ਕਲੱਸਟਰ 'ਤੇ, ਦਿੱਤੇ ਨੋਡ 'ਤੇ, ਸੂਚੀ ਤੋਂ ਰਾਜ ਵਿੱਚ ਸੇਵਾਵਾਂ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਕਹਿੰਦੇ ਹਾਂ। INSTALLED. ਸਾਰੀਆਂ ਸੇਵਾਵਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ, ਨੋਡਸ ਨੂੰ ਰਾਜ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਲਈ Maintenance ਆਦਿ ਸਮਾਨ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ - ਉਹ API ਦੁਆਰਾ ਕੁਝ ਬੇਨਤੀਆਂ ਹਨ।

ਕਲਾਸ ਐਮ.ਸੀ.ਐਸ

ਇਹ ਉਹ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ਕਲਾਸ ਵਾਲਾ ਕੋਡ ਦਾ ਇੱਕ ਟੁਕੜਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ 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) ਸਾਨੂੰ MCS ਵਿੱਚ ਹੋਸਟਨਾਮ ਨੂੰ ਮਸ਼ੀਨ ਦੇ ਨਾਮ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, 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, ਨੋਡਾਂ ਦੀ ਸੂਚੀ ਜੋ ਸਕੇਲਿੰਗ ਲਈ ਮਨਜ਼ੂਰ ਹਨ, ਨਾਲ ਹੀ ਨੋਡ ਕੌਂਫਿਗਰੇਸ਼ਨ ਪੈਰਾਮੀਟਰ: ਮੈਮੋਰੀ ਅਤੇ CPU YARN ਵਿੱਚ ਨੋਡ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਇੱਥੇ 2 ਅੰਦਰੂਨੀ ਪੈਰਾਮੀਟਰ q_ram, q_cpu ਵੀ ਹਨ, ਜੋ ਕਿ ਕਤਾਰ ਹਨ। ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਅਸੀਂ ਮੌਜੂਦਾ ਕਲੱਸਟਰ ਲੋਡ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦੇ ਹਾਂ। ਜੇਕਰ ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਪਿਛਲੇ 5 ਮਿੰਟਾਂ ਵਿੱਚ ਇੱਕ ਲਗਾਤਾਰ ਵਧਿਆ ਲੋਡ ਹੋਇਆ ਹੈ, ਤਾਂ ਅਸੀਂ ਫੈਸਲਾ ਕਰਦੇ ਹਾਂ ਕਿ ਸਾਨੂੰ ਕਲੱਸਟਰ ਵਿੱਚ +1 ਨੋਡ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਇਹੀ ਕਲੱਸਟਰ ਅੰਡਰਯੂਟੀਲਾਈਜ਼ੇਸ਼ਨ ਸਥਿਤੀ ਲਈ ਸੱਚ ਹੈ।

ਉਪਰੋਕਤ ਕੋਡ ਇੱਕ ਫੰਕਸ਼ਨ ਦਾ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜੋ ਇੱਕ ਮਸ਼ੀਨ ਨੂੰ ਕਲੱਸਟਰ ਤੋਂ ਹਟਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਲਾਉਡ ਵਿੱਚ ਰੋਕਦਾ ਹੈ। ਪਹਿਲਾਂ ਇੱਕ ਡੀਕਮਿਸ਼ਨਿੰਗ ਹੈ YARN Nodemanager, ਫਿਰ ਮੋਡ ਚਾਲੂ ਹੁੰਦਾ ਹੈ Maintenance, ਫਿਰ ਅਸੀਂ ਮਸ਼ੀਨ 'ਤੇ ਸਾਰੀਆਂ ਸੇਵਾਵਾਂ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹਾਂ ਅਤੇ ਕਲਾਉਡ ਵਿੱਚ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਨੂੰ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹਾਂ।

2. ਸਕ੍ਰਿਪਟ observer.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, ਜਦੋਂ ਅਸੀਂ ਕਲੱਸਟਰ ਤੋਂ ਕੁਝ ਵੀ ਜੋੜਦੇ ਜਾਂ ਹਟਾਉਂਦੇ ਨਹੀਂ ਹਾਂ, ਪਰ ਬਸ ਲੋਡ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦੇ ਹਾਂ। ਜੇ ਇਹ ਸਥਿਰ ਹੋ ਗਿਆ ਹੈ ਅਤੇ ਅਨੁਕੂਲ ਲੋਡ ਮੁੱਲਾਂ ਦੇ ਗਲਿਆਰੇ ਦੇ ਅੰਦਰ ਹੈ, ਤਾਂ ਅਸੀਂ ਸਿਰਫ਼ ਨਿਗਰਾਨੀ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ। ਜੇ ਇੱਕ ਨੋਡ ਕਾਫ਼ੀ ਨਹੀਂ ਸੀ, ਤਾਂ ਅਸੀਂ ਇੱਕ ਹੋਰ ਜੋੜਦੇ ਹਾਂ.

ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਲਈ ਜਦੋਂ ਸਾਡੇ ਕੋਲ ਇੱਕ ਪਾਠ ਅੱਗੇ ਹੈ, ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਇਹ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਜਾਣਦੇ ਹਾਂ ਕਿ ਇੱਕ ਨੋਡ ਕਾਫ਼ੀ ਨਹੀਂ ਹੋਵੇਗਾ, ਇਸ ਲਈ ਅਸੀਂ ਤੁਰੰਤ ਸਾਰੇ ਮੁਫਤ ਨੋਡਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਪਾਠ ਦੇ ਅੰਤ ਤੱਕ ਉਹਨਾਂ ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਰੱਖਦੇ ਹਾਂ। ਇਹ ਗਤੀਵਿਧੀ ਟਾਈਮਸਟੈਂਪਾਂ ਦੀ ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਾਪਰਦਾ ਹੈ।

ਸਿੱਟਾ

ਆਟੋਸਕੇਲਰ ਉਹਨਾਂ ਮਾਮਲਿਆਂ ਲਈ ਇੱਕ ਚੰਗਾ ਅਤੇ ਸੁਵਿਧਾਜਨਕ ਹੱਲ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਅਸਮਾਨ ਕਲੱਸਟਰ ਲੋਡਿੰਗ ਦਾ ਅਨੁਭਵ ਕਰਦੇ ਹੋ। ਤੁਸੀਂ ਇੱਕੋ ਸਮੇਂ ਪੀਕ ਲੋਡ ਲਈ ਲੋੜੀਦੀ ਕਲੱਸਟਰ ਸੰਰਚਨਾ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ ਅਤੇ ਇਸਦੇ ਨਾਲ ਹੀ ਪੈਸੇ ਦੀ ਬਚਤ ਕਰਦੇ ਹੋਏ, ਅੰਡਰਲੋਡ ਦੌਰਾਨ ਇਸ ਕਲੱਸਟਰ ਨੂੰ ਨਾ ਰੱਖੋ। ਖੈਰ, ਨਾਲ ਹੀ ਇਹ ਸਭ ਤੁਹਾਡੀ ਭਾਗੀਦਾਰੀ ਤੋਂ ਬਿਨਾਂ ਆਪਣੇ ਆਪ ਹੀ ਵਾਪਰਦਾ ਹੈ। ਆਟੋਸਕੇਲਰ ਆਪਣੇ ਆਪ ਵਿੱਚ ਕਲੱਸਟਰ ਮੈਨੇਜਰ API ਅਤੇ ਕਲਾਉਡ ਪ੍ਰਦਾਤਾ API ਨੂੰ ਬੇਨਤੀਆਂ ਦੇ ਇੱਕ ਸਮੂਹ ਤੋਂ ਵੱਧ ਕੁਝ ਨਹੀਂ ਹੈ, ਇੱਕ ਖਾਸ ਤਰਕ ਦੇ ਅਨੁਸਾਰ ਲਿਖਿਆ ਗਿਆ ਹੈ। ਜੋ ਤੁਹਾਨੂੰ ਯਕੀਨੀ ਤੌਰ 'ਤੇ ਯਾਦ ਰੱਖਣ ਦੀ ਲੋੜ ਹੈ ਉਹ ਹੈ 3 ਕਿਸਮਾਂ ਵਿੱਚ ਨੋਡਾਂ ਦੀ ਵੰਡ, ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਲਿਖਿਆ ਸੀ। ਅਤੇ ਤੁਸੀਂ ਖੁਸ਼ ਹੋਵੋਗੇ।

ਸਰੋਤ: www.habr.com