ನಮಸ್ಕಾರ! ದೊಡ್ಡ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಾವು ಜನರಿಗೆ ತರಬೇತಿ ನೀಡುತ್ತೇವೆ. ತನ್ನದೇ ಆದ ಕ್ಲಸ್ಟರ್ ಇಲ್ಲದೆ ದೊಡ್ಡ ಡೇಟಾದಲ್ಲಿ ಶೈಕ್ಷಣಿಕ ಕಾರ್ಯಕ್ರಮವನ್ನು ಕಲ್ಪಿಸುವುದು ಅಸಾಧ್ಯ, ಅದರ ಮೇಲೆ ಎಲ್ಲಾ ಭಾಗವಹಿಸುವವರು ಒಟ್ಟಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ. ಈ ಕಾರಣಕ್ಕಾಗಿ, ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಯಾವಾಗಲೂ ಅದನ್ನು ಹೊಂದಿದೆ :) ನಾವು ಅದರ ಕಾನ್ಫಿಗರೇಶನ್, ಟ್ಯೂನಿಂಗ್ ಮತ್ತು ಆಡಳಿತದಲ್ಲಿ ತೊಡಗಿಸಿಕೊಂಡಿದ್ದೇವೆ ಮತ್ತು ಹುಡುಗರು ಅಲ್ಲಿ MapReduce ಉದ್ಯೋಗಗಳನ್ನು ನೇರವಾಗಿ ಪ್ರಾರಂಭಿಸುತ್ತಾರೆ ಮತ್ತು ಸ್ಪಾರ್ಕ್ ಅನ್ನು ಬಳಸುತ್ತಾರೆ.
ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ ನಾವು ಕ್ಲೌಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಮ್ಮದೇ ಆದ ಆಟೋಸ್ಕೇಲರ್ ಅನ್ನು ಬರೆಯುವ ಮೂಲಕ ಅಸಮ ಕ್ಲಸ್ಟರ್ ಲೋಡಿಂಗ್ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಿದ್ದೇವೆ ಎಂದು ನಾವು ನಿಮಗೆ ಹೇಳುತ್ತೇವೆ. .
ಸಮಸ್ಯೆಯನ್ನು
ನಮ್ಮ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ವಿಶಿಷ್ಟ ಕ್ರಮದಲ್ಲಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ. ವಿಲೇವಾರಿ ಹೆಚ್ಚು ಅಸಮವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಪ್ರಾಯೋಗಿಕ ತರಗತಿಗಳು ಇವೆ, ಎಲ್ಲಾ 30 ಜನರು ಮತ್ತು ಶಿಕ್ಷಕರು ಕ್ಲಸ್ಟರ್‌ಗೆ ಹೋಗಿ ಅದನ್ನು ಬಳಸಲು ಪ್ರಾರಂಭಿಸಿದಾಗ. ಅಥವಾ ಮತ್ತೆ, ಲೋಡ್ ಹೆಚ್ಚು ಹೆಚ್ಚಾದಾಗ ಗಡುವಿನ ಮೊದಲು ದಿನಗಳಿವೆ. ಉಳಿದ ಸಮಯದಲ್ಲಿ ಕ್ಲಸ್ಟರ್ ಅಂಡರ್‌ಲೋಡ್ ಮೋಡ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಪರಿಹಾರ #1 ಗರಿಷ್ಠ ಹೊರೆಗಳನ್ನು ತಡೆದುಕೊಳ್ಳುವ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಇಟ್ಟುಕೊಳ್ಳುವುದು, ಆದರೆ ಉಳಿದ ಸಮಯದಲ್ಲಿ ನಿಷ್ಕ್ರಿಯವಾಗಿರುತ್ತದೆ.
ಪರಿಹಾರ #2 ಒಂದು ಸಣ್ಣ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಇಟ್ಟುಕೊಳ್ಳುವುದು, ತರಗತಿಗಳ ಮೊದಲು ಮತ್ತು ಪೀಕ್ ಲೋಡ್‌ಗಳ ಸಮಯದಲ್ಲಿ ನೀವು ಹಸ್ತಚಾಲಿತವಾಗಿ ನೋಡ್ಗಳನ್ನು ಸೇರಿಸುತ್ತೀರಿ.
ಪರಿಹಾರ #3 ಒಂದು ಸಣ್ಣ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಇಟ್ಟುಕೊಳ್ಳುವುದು ಮತ್ತು ಕ್ಲಸ್ಟರ್ನ ಪ್ರಸ್ತುತ ಲೋಡ್ ಅನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವ ಆಟೋಸ್ಕೇಲರ್ ಅನ್ನು ಬರೆಯುವುದು ಮತ್ತು ವಿವಿಧ API ಗಳನ್ನು ಬಳಸಿ, ಕ್ಲಸ್ಟರ್‌ನಿಂದ ನೋಡ್ಗಳನ್ನು ಸೇರಿಸುವುದು ಮತ್ತು ತೆಗೆದುಹಾಕುವುದು.
ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ ನಾವು ಪರಿಹಾರ # 3 ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ. ಈ ಆಟೋಸ್ಕೇಲರ್ ಆಂತರಿಕ ಅಂಶಗಳಿಗಿಂತ ಹೆಚ್ಚಾಗಿ ಬಾಹ್ಯ ಅಂಶಗಳ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿದೆ ಮತ್ತು ಪೂರೈಕೆದಾರರು ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ಒದಗಿಸುವುದಿಲ್ಲ. ನಾವು Mail.ru ಕ್ಲೌಡ್ ಸೊಲ್ಯೂಷನ್ಸ್ ಕ್ಲೌಡ್ ಮೂಲಸೌಕರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು MCS API ಅನ್ನು ಬಳಸಿಕೊಂಡು ಆಟೋಸ್ಕೇಲರ್ ಅನ್ನು ಬರೆದಿದ್ದೇವೆ. ಮತ್ತು ಡೇಟಾದೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂದು ನಾವು ಕಲಿಸುವುದರಿಂದ, ನಿಮ್ಮ ಸ್ವಂತ ಉದ್ದೇಶಗಳಿಗಾಗಿ ನೀವು ಇದೇ ರೀತಿಯ ಆಟೋಸ್ಕೇಲರ್ ಅನ್ನು ಹೇಗೆ ಬರೆಯಬಹುದು ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಕ್ಲೌಡ್‌ನೊಂದಿಗೆ ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ತೋರಿಸಲು ನಾವು ನಿರ್ಧರಿಸಿದ್ದೇವೆ
ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು
ಮೊದಲಿಗೆ, ನೀವು ಹಡೂಪ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಹೊಂದಿರಬೇಕು. ಉದಾಹರಣೆಗೆ, ನಾವು HDP ವಿತರಣೆಯನ್ನು ಬಳಸುತ್ತೇವೆ.
ನಿಮ್ಮ ನೋಡ್ಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಸೇರಿಸಲು ಮತ್ತು ತೆಗೆದುಹಾಕಲು, ನೀವು ನೋಡ್‌ಗಳ ನಡುವೆ ಪಾತ್ರಗಳ ನಿರ್ದಿಷ್ಟ ವಿತರಣೆಯನ್ನು ಹೊಂದಿರಬೇಕು.
- ಮಾಸ್ಟರ್ ನೋಡ್. ಸರಿ, ಇಲ್ಲಿ ವಿವರಿಸಲು ವಿಶೇಷವಾಗಿ ಏನೂ ಅಗತ್ಯವಿಲ್ಲ: ಕ್ಲಸ್ಟರ್ನ ಮುಖ್ಯ ನೋಡ್, ಉದಾಹರಣೆಗೆ, ನೀವು ಸಂವಾದಾತ್ಮಕ ಮೋಡ್ ಅನ್ನು ಬಳಸಿದರೆ ಸ್ಪಾರ್ಕ್ ಡ್ರೈವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ.
- ದಿನಾಂಕ ನೋಡ್. ಇದು ನೀವು HDFS ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ನೋಡ್ ಮತ್ತು ಅಲ್ಲಿ ಲೆಕ್ಕಾಚಾರಗಳು ನಡೆಯುತ್ತವೆ.
- ಕಂಪ್ಯೂಟಿಂಗ್ ನೋಡ್. ಇದು ನೀವು HDFS ನಲ್ಲಿ ಏನನ್ನೂ ಸಂಗ್ರಹಿಸದಿರುವ ನೋಡ್ ಆಗಿದೆ, ಆದರೆ ಅಲ್ಲಿ ಲೆಕ್ಕಾಚಾರಗಳು ನಡೆಯುತ್ತವೆ.
ಪ್ರಮುಖ ಅಂಶ. ಮೂರನೇ ವಿಧದ ನೋಡ್‌ಗಳಿಂದಾಗಿ ಆಟೋಸ್ಕೇಲಿಂಗ್ ಸಂಭವಿಸುತ್ತದೆ. ನೀವು ಎರಡನೇ ಪ್ರಕಾರದ ನೋಡ್ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಮತ್ತು ಸೇರಿಸಲು ಪ್ರಾರಂಭಿಸಿದರೆ, ಪ್ರತಿಕ್ರಿಯೆಯ ವೇಗವು ತುಂಬಾ ಕಡಿಮೆಯಿರುತ್ತದೆ - ಡಿಕಮಿಷನ್ ಮತ್ತು ರೀಕಾಮಿಟಿಂಗ್ ನಿಮ್ಮ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಗಂಟೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಇದು ಸಹಜವಾಗಿ, ಆಟೋಸ್ಕೇಲಿಂಗ್‌ನಿಂದ ನೀವು ನಿರೀಕ್ಷಿಸುವುದಿಲ್ಲ. ಅಂದರೆ, ನಾವು ಮೊದಲ ಮತ್ತು ಎರಡನೆಯ ವಿಧದ ನೋಡ್ಗಳನ್ನು ಸ್ಪರ್ಶಿಸುವುದಿಲ್ಲ. ಅವರು ಕನಿಷ್ಟ ಕಾರ್ಯಸಾಧ್ಯವಾದ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತಾರೆ, ಅದು ಕಾರ್ಯಕ್ರಮದ ಅವಧಿಯ ಉದ್ದಕ್ಕೂ ಇರುತ್ತದೆ.
ಆದ್ದರಿಂದ, ನಮ್ಮ ಆಟೋಸ್ಕೇಲರ್ ಅನ್ನು ಪೈಥಾನ್ 3 ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ, ಕ್ಲಸ್ಟರ್ ಸೇವೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅಂಬಾರಿ API ಅನ್ನು ಬಳಸುತ್ತದೆ, ಬಳಸುತ್ತದೆ (MCS) ಯಂತ್ರಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಮತ್ತು ನಿಲ್ಲಿಸಲು.
ಪರಿಹಾರ ವಾಸ್ತುಶಿಲ್ಪ
- ಘಟಕ
autoscaler.py. ಇದು ಮೂರು ವರ್ಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: 1) ಅಂಬಾರಿಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಕಾರ್ಯಗಳು, 2) MCS ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಕಾರ್ಯಗಳು, 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 ಇತ್ಯಾದಿಗಳು ಒಂದೇ ರೀತಿ ಕಾಣುತ್ತವೆ - ಅವು API ಮೂಲಕ ಕೆಲವೇ ವಿನಂತಿಗಳು.
ವರ್ಗ Mcs
ಒಂದು ವರ್ಗವನ್ನು ಹೊಂದಿರುವ ಕೋಡ್‌ನ ತುಣುಕು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ 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