API ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಲು API ವಿನಂತಿಗಳು ಮತ್ತು ಸಾಧನಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಉತ್ಪಾದಿಸಲು ಸಾಧ್ಯವಾದಾಗ ಪ್ರೋಗ್ರಾಂ ಕೋಡ್‌ನೊಂದಿಗೆ ಬಳಸಿದಾಗ API ಗಳೊಂದಿಗಿನ ಸಂವಹನದ ಸಂಪೂರ್ಣ ಶಕ್ತಿಯನ್ನು ಬಹಿರಂಗಪಡಿಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಇನ್ನೂ ಗಮನಿಸದೆ ಉಳಿದಿದೆ ಪೈಥಾನ್ ಸಾಫ್ಟ್‌ವೇರ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಕಿಟ್ (ಇನ್ನು ಮುಂದೆ ಪೈಥಾನ್ SDK ಎಂದು ಉಲ್ಲೇಖಿಸಲಾಗುತ್ತದೆ) ಗಾಗಿ ಪಾಯಿಂಟ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ API ಪರಿಶೀಲಿಸಿ, ಆದರೆ ವ್ಯರ್ಥವಾಯಿತು. ಇದು ಅಭಿವರ್ಧಕರು ಮತ್ತು ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಉತ್ಸಾಹಿಗಳ ಜೀವನವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸರಳಗೊಳಿಸುತ್ತದೆ. ಪೈಥಾನ್ ಇತ್ತೀಚೆಗೆ ಅಗಾಧ ಜನಪ್ರಿಯತೆಯನ್ನು ಗಳಿಸಿದೆ ಮತ್ತು ನಾನು ಅಂತರವನ್ನು ತುಂಬಲು ಮತ್ತು ಮುಖ್ಯ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ನಿರ್ಧರಿಸಿದೆ. . ಈ ಲೇಖನವು Habré ಕುರಿತು ಮತ್ತೊಂದು ಲೇಖನಕ್ಕೆ ಅತ್ಯುತ್ತಮವಾದ ಸೇರ್ಪಡೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ . ಪೈಥಾನ್ SDK ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಹೇಗೆ ಬರೆಯುವುದು ಎಂಬುದನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ ಮತ್ತು ಆವೃತ್ತಿ 1.6 (R80.40 ರಿಂದ ಬೆಂಬಲಿತವಾಗಿದೆ) ನಲ್ಲಿ ಹೊಸ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ API ಕಾರ್ಯವನ್ನು ಹತ್ತಿರದಿಂದ ನೋಡೋಣ. ಲೇಖನವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ನಿಮಗೆ API ಗಳು ಮತ್ತು ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಮೂಲಭೂತ ಜ್ಞಾನದ ಅಗತ್ಯವಿದೆ.
ಚೆಕ್ ಪಾಯಿಂಟ್ API ಅನ್ನು ಸಕ್ರಿಯವಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿದೆ ಮತ್ತು ಈ ಸಮಯದಲ್ಲಿ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಬಿಡುಗಡೆ ಮಾಡಲಾಗಿದೆ:
- - API ಮೂಲಕ ನಿಯಂತ್ರಣ ಸರ್ವರ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ (ಮತ್ತು ನಿಯಂತ್ರಣ ಸರ್ವರ್‌ನಿಂದ ನಿಯಂತ್ರಿಸಲ್ಪಡುವ ಗೇಟ್‌ವೇಗಳಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಾಮರ್ಥ್ಯ)
- - ಭದ್ರತಾ ಗೇಟ್‌ವೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ
- — ಚೆಕ್ ಪಾಯಿಂಟ್ ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು
- - ಗೇಟ್‌ವೇಗಳಲ್ಲಿ ಐಡೆಂಟಿಟಿ ಅವೇರ್ನೆಸ್ ಬ್ಲೇಡ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು
- - SMB ಗೇಟ್‌ವೇ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಪೋರ್ಟಲ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ ()
- - IoT ನಿಯಂತ್ರಕಗಳೊಂದಿಗೆ ಸಂವಹನ
- - ಜೊತೆ ಕೆಲಸ ಮಾಡಿ (SD-WAN ಭದ್ರತಾ ಪರಿಹಾರ)
- - ಜೊತೆ ಕೆಲಸ ಮಾಡಿ
ಪೈಥಾನ್ SDK ಪ್ರಸ್ತುತ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ API ಮತ್ತು ಜೊತೆಗೆ ಸಂವಹನವನ್ನು ಮಾತ್ರ ಬೆಂಬಲಿಸುತ್ತದೆ ಗಯಾ API. ಈ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ನಾವು ಪ್ರಮುಖ ವರ್ಗಗಳು, ವಿಧಾನಗಳು ಮತ್ತು ಅಸ್ಥಿರಗಳನ್ನು ನೋಡುತ್ತೇವೆ.
ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ
ಘಟಕ cpapi ನಿಂದ ತ್ವರಿತವಾಗಿ ಮತ್ತು ಸುಲಭವಾಗಿ ಸ್ಥಾಪಿಸುತ್ತದೆ ಸಹಾಯದಿಂದ ಪಿಪ್. ವಿವರವಾದ ಅನುಸ್ಥಾಪನಾ ಸೂಚನೆಗಳು ಲಭ್ಯವಿದೆ . ಈ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಪೈಥಾನ್ ಆವೃತ್ತಿಗಳು 2.7 ಮತ್ತು 3.7 ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅಳವಡಿಸಲಾಗಿದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ಪೈಥಾನ್ 3.7 ಬಳಸಿ ಉದಾಹರಣೆಗಳನ್ನು ನೀಡಲಾಗುವುದು. ಆದಾಗ್ಯೂ, ಪೈಥಾನ್ SDK ಅನ್ನು ಚೆಕ್ ಪಾಯಿಂಟ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಸರ್ವರ್ (ಸ್ಮಾರ್ಟ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್) ನಿಂದ ನೇರವಾಗಿ ಚಲಾಯಿಸಬಹುದು, ಆದರೆ ಅವು ಪೈಥಾನ್ 2.7 ಅನ್ನು ಮಾತ್ರ ಬೆಂಬಲಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ ಕೊನೆಯ ವಿಭಾಗವು ಆವೃತ್ತಿ 2.7 ಗಾಗಿ ಕೋಡ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ತಕ್ಷಣ, ಡೈರೆಕ್ಟರಿಗಳಲ್ಲಿನ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ ಉದಾಹರಣೆಗಳು_ಪೈಥಾನ್2 и ಉದಾಹರಣೆಗಳು_ಪೈಥಾನ್3.
ಆರಂಭಿಸುವಿಕೆ
ನಾವು cpapi ಮಾಡ್ಯೂಲ್‌ನ ಘಟಕಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸಾಧ್ಯವಾಗುವಂತೆ, ನಾವು ಮಾಡ್ಯೂಲ್‌ನಿಂದ ಆಮದು ಮಾಡಿಕೊಳ್ಳಬೇಕು cpapi ಕನಿಷ್ಠ ಎರಡು ಅಗತ್ಯವಿರುವ ವರ್ಗಗಳು:
ಎಪಿಕ್ಲೈಂಟ್ и APIClientArgs
from cpapi import APIClient, APIClientArgs
ಕ್ಲಾಸ್ APIClientArgs API ಸರ್ವರ್ ಮತ್ತು ವರ್ಗಕ್ಕೆ ಸಂಪರ್ಕ ನಿಯತಾಂಕಗಳಿಗೆ ಕಾರಣವಾಗಿದೆ ಎಪಿಕ್ಲೈಂಟ್ API ನೊಂದಿಗೆ ಸಂವಹನಕ್ಕೆ ಕಾರಣವಾಗಿದೆ.
ಸಂಪರ್ಕ ನಿಯತಾಂಕಗಳನ್ನು ನಿರ್ಧರಿಸುವುದು
API ಗೆ ಸಂಪರ್ಕಿಸಲು ವಿವಿಧ ನಿಯತಾಂಕಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು, ನೀವು ವರ್ಗದ ಉದಾಹರಣೆಯನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ APIClientArgs. ತಾತ್ವಿಕವಾಗಿ, ಅದರ ನಿಯತಾಂಕಗಳನ್ನು ಪೂರ್ವನಿರ್ಧರಿತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ನಿಯಂತ್ರಣ ಸರ್ವರ್ನಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ, ಅವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿಲ್ಲ.
client_args = APIClientArgs()ಆದರೆ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಹೋಸ್ಟ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, ನೀವು ಕನಿಷ್ಟ IP ವಿಳಾಸ ಅಥವಾ API ಸರ್ವರ್‌ನ ಹೋಸ್ಟ್ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು (ನಿರ್ವಹಣೆ ಸರ್ವರ್ ಎಂದೂ ಸಹ ಕರೆಯಲಾಗುತ್ತದೆ). ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಸರ್ವರ್ ಸಂಪರ್ಕ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ ಮತ್ತು ನಿರ್ವಹಣಾ ಸರ್ವರ್‌ನ IP ವಿಳಾಸವನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನಂತೆ ನಿಯೋಜಿಸುತ್ತೇವೆ.
client_args = APIClientArgs(server='192.168.47.241')API ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸುವಾಗ ಬಳಸಬಹುದಾದ ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳು ಮತ್ತು ಅವುಗಳ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ನೋಡೋಣ:
APIClientArgs ವರ್ಗದ __init__ ವಿಧಾನದ ವಾದಗಳು
class APIClientArgs:
"""
This class provides arguments for APIClient configuration.
All the arguments are configured with their default values.
"""
# port is set to None by default, but it gets replaced with 443 if not specified
# context possible values - web_api (default) or gaia_api
def __init__(self, port=None, fingerprint=None, sid=None, server="127.0.0.1", http_debug_level=0,
api_calls=None, debug_file="", proxy_host=None, proxy_port=8080,
api_version=None, unsafe=False, unsafe_auto_accept=False, context="web_api"):
self.port = port
# management server fingerprint
self.fingerprint = fingerprint
# session-id.
self.sid = sid
# management server name or IP-address
self.server = server
# debug level
self.http_debug_level = http_debug_level
# an array with all the api calls (for debug purposes)
self.api_calls = api_calls if api_calls else []
# name of debug file. If left empty, debug data will not be saved to disk.
self.debug_file = debug_file
# HTTP proxy server address (without "http://")
self.proxy_host = proxy_host
# HTTP proxy port
self.proxy_port = proxy_port
# Management server's API version
self.api_version = api_version
# Indicates that the client should not check the server's certificate
self.unsafe = unsafe
# Indicates that the client should automatically accept and save the server's certificate
self.unsafe_auto_accept = unsafe_auto_accept
# The context of using the client - defaults to web_api
self.context = contextAPIClientArgs ವರ್ಗದ ನಿದರ್ಶನಗಳಲ್ಲಿ ಬಳಸಬಹುದಾದ ವಾದಗಳು ಚೆಕ್ ಪಾಯಿಂಟ್ ನಿರ್ವಾಹಕರಿಗೆ ಅರ್ಥಗರ್ಭಿತವಾಗಿವೆ ಮತ್ತು ಹೆಚ್ಚುವರಿ ಕಾಮೆಂಟ್‌ಗಳ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ನಾನು ನಂಬುತ್ತೇನೆ.
APClient ಮತ್ತು ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ಮೂಲಕ ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ
ಕ್ಲಾಸ್ ಎಪಿಕ್ಲೈಂಟ್ ಅದನ್ನು ಬಳಸಲು ಅತ್ಯಂತ ಅನುಕೂಲಕರ ಮಾರ್ಗವೆಂದರೆ ಸಂದರ್ಭ ನಿರ್ವಾಹಕರ ಮೂಲಕ. APIClient ವರ್ಗದ ನಿದರ್ಶನಕ್ಕೆ ರವಾನಿಸಬೇಕಾಗಿರುವುದು ಹಿಂದಿನ ಹಂತದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಸಂಪರ್ಕ ನಿಯತಾಂಕಗಳು.
with APIClient(client_args) as client:
ಕಾಂಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನೇಜರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ API ಸರ್ವರ್‌ಗೆ ಲಾಗಿನ್ ಕರೆ ಮಾಡುವುದಿಲ್ಲ, ಆದರೆ ಲಾಗ್ ಔಟ್ ಮಾಡುವಾಗ ಲಾಗ್‌ಔಟ್ ಕರೆ ಮಾಡುತ್ತದೆ. ಕೆಲವು ಕಾರಣಗಳಿಗಾಗಿ API ಕರೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿದ ನಂತರ ಲಾಗ್‌ಔಟ್ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ, ನೀವು ಸಂದರ್ಭ ನಿರ್ವಾಹಕವನ್ನು ಬಳಸದೆಯೇ ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಬೇಕು:
client = APIClient(clieng_args)ಸಂಪರ್ಕವನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ
ಸಂಪರ್ಕವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಿಯತಾಂಕಗಳನ್ನು ಪೂರೈಸುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ ವಿಧಾನವನ್ನು ಬಳಸುವುದು ಚೆಕ್_ಫಿಂಗರ್ಪ್ರಿಂಟ್. ಸರ್ವರ್ API ಪ್ರಮಾಣಪತ್ರದ ಫಿಂಗರ್‌ಪ್ರಿಂಟ್‌ಗಾಗಿ sha1 ಹ್ಯಾಶ್ ಮೊತ್ತದ ಪರಿಶೀಲನೆಯು ವಿಫಲವಾದಲ್ಲಿ (ವಿಧಾನವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗಿದೆ ತಪ್ಪು), ನಂತರ ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಪರ್ಕ ಸಮಸ್ಯೆಗಳಿಂದ ಉಂಟಾಗುತ್ತದೆ ಮತ್ತು ನಾವು ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನಿಲ್ಲಿಸಬಹುದು (ಅಥವಾ ಸಂಪರ್ಕ ಡೇಟಾವನ್ನು ಸರಿಪಡಿಸಲು ಬಳಕೆದಾರರಿಗೆ ಅವಕಾಶವನ್ನು ನೀಡಬಹುದು):
if client.check_fingerprint() is False:
print("Could not get the server's fingerprint - Check connectivity with the server.")
exit(1)
ಭವಿಷ್ಯದಲ್ಲಿ ವರ್ಗ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ ಎಪಿಕ್ಲೈಂಟ್ ಪ್ರತಿ API ಕರೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ (ವಿಧಾನಗಳು api_call и api_query, ನಾವು ಅವರ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಮುಂದೆ ಮಾತನಾಡುತ್ತೇವೆ) API ಸರ್ವರ್ನಲ್ಲಿ sha1 ಫಿಂಗರ್ಪ್ರಿಂಟ್ ಪ್ರಮಾಣಪತ್ರ. ಆದರೆ, API ಸರ್ವರ್ ಪ್ರಮಾಣಪತ್ರದ sha1 ಫಿಂಗರ್ಪ್ರಿಂಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವಾಗ, ದೋಷ ಕಂಡುಬಂದರೆ (ಪ್ರಮಾಣಪತ್ರವು ತಿಳಿದಿಲ್ಲ ಅಥವಾ ಬದಲಾಯಿಸಲಾಗಿದೆ), ವಿಧಾನ ಚೆಕ್_ಫಿಂಗರ್ಪ್ರಿಂಟ್ ಸ್ಥಳೀಯ ಗಣಕದಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅದರ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸೇರಿಸಲು/ಬದಲಾಯಿಸಲು ಅವಕಾಶವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಪರಿಶೀಲನೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಬಹುದು (ಆದರೆ 127.0.0.1 ಗೆ ಸಂಪರ್ಕಿಸುವಾಗ API ಸರ್ವರ್‌ನಲ್ಲಿಯೇ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಚಲಾಯಿಸಿದರೆ ಮಾತ್ರ ಇದನ್ನು ಶಿಫಾರಸು ಮಾಡಬಹುದು), APIClientArgs ಆರ್ಗ್ಯುಮೆಂಟ್ ಬಳಸಿ - ಅಸುರಕ್ಷಿತ_ಸ್ವಯಂ_ಒಪ್ಪಿಸು (APIClientArgs ಕುರಿತು "ಕನೆಕ್ಷನ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು" ನಲ್ಲಿ ಹಿಂದಿನದನ್ನು ನೋಡಿ).
client_args = APIClientArgs(unsafe_auto_accept=True)API ಸರ್ವರ್‌ಗೆ ಲಾಗಿನ್ ಮಾಡಿ
У ಎಪಿಕ್ಲೈಂಟ್ API ಸರ್ವರ್‌ಗೆ ಲಾಗ್ ಇನ್ ಮಾಡಲು 3 ವಿಧಾನಗಳಿವೆ, ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ ಅರ್ಥವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತದೆ ಸಿದ್(ಸೆಷನ್-ಐಡಿ), ಇದನ್ನು ಹೆಡರ್‌ನಲ್ಲಿನ ಪ್ರತಿ ನಂತರದ API ಕರೆಯಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ (ಈ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಹೆಡರ್‌ನಲ್ಲಿರುವ ಹೆಸರು X-chkp-sid), ಆದ್ದರಿಂದ ಈ ನಿಯತಾಂಕವನ್ನು ಮತ್ತಷ್ಟು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.
ಲಾಗಿನ್ ವಿಧಾನ
ಲಾಗಿನ್ ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ಬಳಸುವ ಆಯ್ಕೆ (ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರಹೆಸರು ನಿರ್ವಹಣೆ ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ 1q2w3e ಅನ್ನು ಸ್ಥಾನಿಕ ವಾದಗಳಾಗಿ ರವಾನಿಸಲಾಗಿದೆ):
login = client.login('admin', '1q2w3e') ಲಾಗಿನ್ ವಿಧಾನದಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಐಚ್ಛಿಕ ನಿಯತಾಂಕಗಳು ಸಹ ಲಭ್ಯವಿವೆ; ಅವುಗಳ ಹೆಸರುಗಳು ಮತ್ತು ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳು ಇಲ್ಲಿವೆ:
continue_last_session=False, domain=None, read_only=False, payload=Noneವಿಧಾನ ಲಾಗಿನ್_with_api_key
Api ಕೀಯನ್ನು ಬಳಸುವ ಆಯ್ಕೆ (ನಿರ್ವಹಣೆಯ ಆವೃತ್ತಿ R80.40/Management API v1.6 ರಿಂದ ಬೆಂಬಲಿತವಾಗಿದೆ, "3TsbPJ8ZKjaJGvFyoFqHFA==" ಇದು API ಕೀ ದೃಢೀಕರಣ ವಿಧಾನದೊಂದಿಗೆ ನಿರ್ವಹಣಾ ಸರ್ವರ್ನಲ್ಲಿ ಬಳಕೆದಾರರಲ್ಲಿ ಒಬ್ಬರಿಗೆ API ಕೀ ಮೌಲ್ಯವಾಗಿದೆ):
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') ವಿಧಾನದಲ್ಲಿ api_ಕೀಲಿಯೊಂದಿಗೆ_ಲಾಗಿನ್ ಮಾಡಿ ವಿಧಾನದಲ್ಲಿರುವಂತೆಯೇ ಅದೇ ಐಚ್ಛಿಕ ನಿಯತಾಂಕಗಳು ಲಭ್ಯವಿದೆ ಲಾಗಿನ್.
ಲಾಗಿನ್_ಆಸ್_ರೂಟ್ ವಿಧಾನ
API ಸರ್ವರ್‌ನೊಂದಿಗೆ ಸ್ಥಳೀಯ ಯಂತ್ರಕ್ಕೆ ಲಾಗಿನ್ ಮಾಡುವ ಆಯ್ಕೆ:
login = client.login_as_root()ಈ ವಿಧಾನಕ್ಕೆ ಕೇವಲ ಎರಡು ಐಚ್ಛಿಕ ನಿಯತಾಂಕಗಳು ಲಭ್ಯವಿವೆ:
domain=None, payload=Noneಮತ್ತು ಅಂತಿಮವಾಗಿ API ತಮ್ಮನ್ನು ಕರೆದುಕೊಳ್ಳುತ್ತದೆ
ವಿಧಾನಗಳ ಮೂಲಕ API ಕರೆಗಳನ್ನು ಮಾಡಲು ನಮಗೆ ಎರಡು ಆಯ್ಕೆಗಳಿವೆ api_call и api_query. ಅವುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು ಎಂದು ಲೆಕ್ಕಾಚಾರ ಮಾಡೋಣ.
api_call
ಈ ವಿಧಾನವು ಯಾವುದೇ ಕರೆಗಳಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ. ಅಗತ್ಯವಿದ್ದರೆ ನಾವು Api ಕರೆ ಮತ್ತು ವಿನಂತಿಯ ದೇಹದಲ್ಲಿ ಪೇಲೋಡ್‌ಗಾಗಿ ಕೊನೆಯ ಭಾಗವನ್ನು ರವಾನಿಸಬೇಕಾಗಿದೆ. ಪೇಲೋಡ್ ಖಾಲಿಯಾಗಿದ್ದರೆ, ಅದನ್ನು ವರ್ಗಾಯಿಸಲಾಗುವುದಿಲ್ಲ:
api_versions = client.api_call('show-api-versions') ಕಟ್‌ನ ಕೆಳಗೆ ಈ ವಿನಂತಿಗಾಗಿ ಔಟ್ಪುಟ್:
In [23]: api_versions
Out[23]:
APIResponse({
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"res_obj": {
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"status_code": 200
},
"status_code": 200,
"success": true
})
show_host = client.api_call('show-host', {'name' : 'h_8.8.8.8'})ಕಟ್‌ನ ಕೆಳಗೆ ಈ ವಿನಂತಿಗಾಗಿ ಔಟ್ಪುಟ್:
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"res_obj": {
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"status_code": 200
},
"status_code": 200,
"success": true
})
api_query
ಈ ವಿಧಾನವು ಆಫ್‌ಸೆಟ್ ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಔಟ್ಪುಟ್ ಕರೆಗಳಿಗೆ ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತದೆ ಎಂದು ನಾನು ಈಗಿನಿಂದಲೇ ಕಾಯ್ದಿರಿಸುತ್ತೇನೆ. ಅಂತಹ ತೀರ್ಮಾನವು ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುವಾಗ ಅಥವಾ ಒಳಗೊಂಡಿರುವಾಗ ಸಂಭವಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಿರ್ವಹಣಾ ಸರ್ವರ್ನಲ್ಲಿ ರಚಿಸಲಾದ ಎಲ್ಲಾ ಹೋಸ್ಟ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಪಟ್ಟಿಗಾಗಿ ಇದು ವಿನಂತಿಯಾಗಿರಬಹುದು. ಅಂತಹ ವಿನಂತಿಗಳಿಗಾಗಿ, API ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ 50 ವಸ್ತುಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ (ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿ ನೀವು ಮಿತಿಯನ್ನು 500 ವಸ್ತುಗಳಿಗೆ ಹೆಚ್ಚಿಸಬಹುದು). ಮತ್ತು API ವಿನಂತಿಯಲ್ಲಿ ಆಫ್‌ಸೆಟ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಮಾಹಿತಿಯನ್ನು ಹಲವಾರು ಬಾರಿ ಎಳೆಯದಿರಲು, ಈ ಕೆಲಸವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮಾಡುವ api_query ವಿಧಾನವಿದೆ. ಈ ವಿಧಾನದ ಅಗತ್ಯವಿರುವ ಕರೆಗಳ ಉದಾಹರಣೆಗಳು: ಶೋ-ಸೆಶನ್‌ಗಳು, ಶೋ-ಹೋಸ್ಟ್‌ಗಳು, ಶೋ-ನೆಟ್‌ವರ್ಕ್‌ಗಳು, ಶೋ-ವೈಲ್ಡ್‌ಕಾರ್ಡ್‌ಗಳು, ಶೋ-ಗ್ರೂಪ್‌ಗಳು, ಶೋ-ವಿಳಾಸ-ವ್ಯಾಪ್ತಿಗಳು, ಶೋ-ಸರಳ-ಗೇಟ್‌ವೇಗಳು, ಶೋ-ಸರಳ-ಕ್ಲಸ್ಟರ್‌ಗಳು, ಶೋ-ಪ್ರವೇಶ-ಪಾತ್ರಗಳು, ಶೋ-ವಿಶ್ವಾಸಾರ್ಹ-ಕ್ಲೈಂಟ್‌ಗಳು ಪ್ರದರ್ಶನ-ಪ್ಯಾಕೇಜುಗಳು. ವಾಸ್ತವವಾಗಿ, ನಾವು ಈ API ಕರೆಗಳ ಹೆಸರಿನಲ್ಲಿ ಬಹುವಚನ ಪದಗಳನ್ನು ನೋಡುತ್ತೇವೆ, ಆದ್ದರಿಂದ ಈ ಕರೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗುತ್ತದೆ api_query
show_hosts = client.api_query('show-hosts') ಕಟ್‌ನ ಕೆಳಗೆ ಈ ವಿನಂತಿಗಾಗಿ ಔಟ್ಪುಟ್:
In [21]: show_hosts
Out[21]:
APIResponse({
"data": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"res_obj": {
"data": {
"from": 1,
"objects": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"to": 2,
"total": 2
},
"status_code": 200
},
"status_code": 200,
"success": true
})
API ಕರೆಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿದೆ
ಇದರ ನಂತರ ನೀವು ವರ್ಗದ ಅಸ್ಥಿರ ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಬಳಸಬಹುದು APIR ಪ್ರತಿಕ್ರಿಯೆ(ಸಂದರ್ಭ ನಿರ್ವಾಹಕ ಒಳಗೆ ಮತ್ತು ಹೊರಗೆ ಎರಡೂ). ತರಗತಿಯಲ್ಲಿ APIR ಪ್ರತಿಕ್ರಿಯೆ 4 ವಿಧಾನಗಳು ಮತ್ತು 5 ಅಸ್ಥಿರಗಳನ್ನು ಪೂರ್ವನಿರ್ಧರಿತಗೊಳಿಸಲಾಗಿದೆ; ನಾವು ಪ್ರಮುಖವಾದವುಗಳ ಮೇಲೆ ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಾಸಿಸುತ್ತೇವೆ.
ಯಶಸ್ಸು
ಪ್ರಾರಂಭಿಸಲು, API ಕರೆ ಯಶಸ್ವಿಯಾಗಿದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು ಒಳ್ಳೆಯದು. ಇದಕ್ಕೆ ಒಂದು ವಿಧಾನವಿದೆ ಯಶಸ್ಸು:
In [49]: api_versions.success
Out[49]: True
API ಕರೆ ಯಶಸ್ವಿಯಾದರೆ ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ (ಪ್ರತಿಕ್ರಿಯೆ ಕೋಡ್ - 200) ಮತ್ತು ವಿಫಲವಾದರೆ ತಪ್ಪು (ಯಾವುದೇ ಪ್ರತಿಕ್ರಿಯೆ ಕೋಡ್). ಪ್ರತಿಕ್ರಿಯೆ ಕೋಡ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ವಿಭಿನ್ನ ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು API ಕರೆ ನಂತರ ತಕ್ಷಣವೇ ಬಳಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) ಸ್ಥಿತಿ ಕೋಡ್
API ಕರೆ ಮಾಡಿದ ನಂತರ ಪ್ರತಿಕ್ರಿಯೆ ಕೋಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
In [62]: api_versions.status_code
Out[62]: 400
ಸಂಭಾವ್ಯ ಪ್ರತಿಕ್ರಿಯೆ ಕೋಡ್‌ಗಳು: 200,400,401,403,404,409,500,501.
ಸೆಟ್_ಯಶಸ್ಸಿನ_ಸ್ಥಿತಿ
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಯಶಸ್ಸಿನ ಸ್ಥಿತಿಯ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುವುದು ಅಗತ್ಯವಾಗಬಹುದು. ತಾಂತ್ರಿಕವಾಗಿ, ನೀವು ಅಲ್ಲಿ ಏನನ್ನಾದರೂ ಹಾಕಬಹುದು, ಸಾಮಾನ್ಯ ಸ್ಟ್ರಿಂಗ್ ಕೂಡ. ಆದರೆ ಕೆಲವು ಜೊತೆಗಿನ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಈ ನಿಯತಾಂಕವನ್ನು ತಪ್ಪಿಗೆ ಮರುಹೊಂದಿಸುವುದು ನಿಜವಾದ ಉದಾಹರಣೆಯಾಗಿದೆ. ಕೆಳಗೆ, ನಿರ್ವಹಣಾ ಸರ್ವರ್ನಲ್ಲಿ ಕಾರ್ಯಗಳು ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಉದಾಹರಣೆಗೆ ಗಮನ ಕೊಡಿ, ಆದರೆ ಈ ವಿನಂತಿಯು ವಿಫಲವಾಗಿದೆ ಎಂದು ನಾವು ಪರಿಗಣಿಸುತ್ತೇವೆ (ನಾವು ಯಶಸ್ಸಿನ ವೇರಿಯಬಲ್ ಅನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ ತಪ್ಪು, API ಕರೆ ಯಶಸ್ವಿಯಾಗಿದೆ ಮತ್ತು ಕೋಡ್ 200 ಅನ್ನು ಹಿಂದಿರುಗಿಸಿದರೂ ಸಹ).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakಪ್ರತಿಕ್ರಿಯೆ ()
ಪ್ರತಿಕ್ರಿಯೆಯ ವಿಧಾನವು ನಿಘಂಟನ್ನು ಪ್ರತಿಕ್ರಿಯೆ ಕೋಡ್ (status_code) ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯ ದೇಹ (ದೇಹ) ನೊಂದಿಗೆ ವೀಕ್ಷಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
In [94]: api_versions.response()
Out[94]:
{'status_code': 200,
'data': {'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}}
ಡೇಟಾ
ಅನಗತ್ಯ ಮಾಹಿತಿಯಿಲ್ಲದೆ ಪ್ರತಿಕ್ರಿಯೆಯ (ದೇಹ) ದೇಹವನ್ನು ಮಾತ್ರ ನೋಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
In [93]: api_versions.data
Out[93]:
{'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}
ತಪ್ಪು ಸಂದೇಶ
API ವಿನಂತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ ದೋಷ ಸಂಭವಿಸಿದಾಗ ಮಾತ್ರ ಈ ಮಾಹಿತಿಯು ಲಭ್ಯವಿರುತ್ತದೆ (ಪ್ರತಿಕ್ರಿಯೆ ಕೋಡ್ ಕೇವಲ 200) ಉದಾಹರಣೆ ಔಟ್ಪುಟ್
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
ಉಪಯುಕ್ತ ಉದಾಹರಣೆಗಳು
ನಿರ್ವಹಣಾ API 1.6 ರಲ್ಲಿ ಸೇರಿಸಲಾದ API ಕರೆಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳನ್ನು ಈ ಕೆಳಗಿನವುಗಳಾಗಿವೆ.
ಮೊದಲಿಗೆ, ಕರೆಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನೋಡೋಣ ಆಡ್-ಹೋಸ್ಟ್ и ಸೇರಿಸಿ-ವಿಳಾಸ-ವ್ಯಾಪ್ತಿ. ನಾವು ಸಬ್ನೆಟ್ 192.168.0.0/24 ನ ಎಲ್ಲಾ IP ವಿಳಾಸಗಳನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ ಎಂದು ಹೇಳೋಣ, ಅದರಲ್ಲಿ ಕೊನೆಯ ಆಕ್ಟೆಟ್ 5 ಆಗಿದೆ, ಹೋಸ್ಟ್ ಪ್ರಕಾರದ ವಸ್ತುಗಳಂತೆ ಮತ್ತು ಎಲ್ಲಾ ಇತರ IP ವಿಳಾಸಗಳನ್ನು ವಿಳಾಸ ಶ್ರೇಣಿಯ ಪ್ರಕಾರದ ವಸ್ತುಗಳಂತೆ ಬರೆಯಿರಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸಬ್ನೆಟ್ ವಿಳಾಸ ಮತ್ತು ಪ್ರಸಾರ ವಿಳಾಸವನ್ನು ಹೊರತುಪಡಿಸಿ.
ಆದ್ದರಿಂದ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಮತ್ತು ಹೋಸ್ಟ್ ಪ್ರಕಾರದ 50 ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ಮತ್ತು ವಿಳಾಸ ಶ್ರೇಣಿಯ 51 ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಕೆಳಗೆ ಇದೆ. ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, 101 API ಕರೆಗಳ ಅಗತ್ಯವಿದೆ (ಅಂತಿಮ ಪ್ರಕಟಣೆಯ ಕರೆಯನ್ನು ಲೆಕ್ಕಿಸುವುದಿಲ್ಲ). ಅಲ್ಲದೆ, ಟೈಮ್‌ಇಟ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು, ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರಕಟಿಸುವವರೆಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ತೆಗೆದುಕೊಳ್ಳುವ ಸಮಯವನ್ನು ನಾವು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ.
ಆಡ್-ಹೋಸ್ಟ್ ಮತ್ತು ಆಡ್-ವಿಳಾಸ-ಶ್ರೇಣಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಕ್ರಿಪ್ಟ್
import timeit
from cpapi import APIClient, APIClientArgs
start = timeit.default_timer()
first_ip = 1
last_ip = 4
client_args = APIClientArgs(server="192.168.47.240")
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
for ip in range(5,255,5):
add_host = client.api_call("add-host", {"name" : f"h_192.168.0.{ip}", "ip-address": f'192.168.0.{ip}'})
while last_ip < 255:
add_range = client.api_call("add-address-range", {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"})
first_ip+=5
last_ip+=5
stop = timeit.default_timer()
publish = client.api_call("publish")
print(f'Time to execute batch request: {stop - start} seconds')
ನನ್ನ ಲ್ಯಾಬ್ ಪರಿಸರದಲ್ಲಿ, ನಿರ್ವಹಣಾ ಸರ್ವರ್‌ನಲ್ಲಿನ ಲೋಡ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗತಗೊಳಿಸಲು 30 ಮತ್ತು 50 ಸೆಕೆಂಡುಗಳ ನಡುವೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
API ಕರೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅದೇ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುವುದು ಎಂದು ಈಗ ನೋಡೋಣ ಆಡ್-ಆಬ್ಜೆಕ್ಟ್ಸ್-ಬ್ಯಾಚ್, ಇದಕ್ಕೆ ಬೆಂಬಲವನ್ನು API ಆವೃತ್ತಿ 1.6 ರಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ. ಒಂದು API ವಿನಂತಿಯಲ್ಲಿ ಏಕಕಾಲದಲ್ಲಿ ಅನೇಕ ವಸ್ತುಗಳನ್ನು ರಚಿಸಲು ಈ ಕರೆ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದಲ್ಲದೆ, ಇವುಗಳು ವಿವಿಧ ರೀತಿಯ ವಸ್ತುಗಳಾಗಿರಬಹುದು (ಉದಾಹರಣೆಗೆ, ಹೋಸ್ಟ್‌ಗಳು, ಸಬ್‌ನೆಟ್‌ಗಳು ಮತ್ತು ವಿಳಾಸ ಶ್ರೇಣಿಗಳು). ಹೀಗಾಗಿ, ನಮ್ಮ ಕಾರ್ಯವನ್ನು ಒಂದು API ಕರೆ ಚೌಕಟ್ಟಿನೊಳಗೆ ಪರಿಹರಿಸಬಹುದು.
ಆಡ್-ಆಬ್ಜೆಕ್ಟ್ಸ್-ಬ್ಯಾಚ್ ಬಳಸಿ ಸ್ಕ್ರಿಪ್ಟ್
import timeit
from cpapi import APIClient, APIClientArgs
start = timeit.default_timer()
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
for ip in range(5,255,5):
data = {"name": f'h_192.168.0.{ip}', "ip-address": f'192.168.0.{ip}'}
objects_list_ip.append(data)
first_ip = 1
last_ip = 4
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"}
objects_list_range.append(data)
first_ip+=5
last_ip+=5
data_for_batch = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip
}, {
"type" : "address-range",
"list" : objects_list_range
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
add_objects_batch = client.api_call("add-objects-batch", data_for_batch)
stop = timeit.default_timer()
publish = client.api_call("publish")
print(f'Time to execute batch request: {stop - start} seconds')
ಮತ್ತು ನನ್ನ ಲ್ಯಾಬ್ ಪರಿಸರದಲ್ಲಿ ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಲು 3 ರಿಂದ 7 ಸೆಕೆಂಡುಗಳವರೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ನಿರ್ವಹಣೆ ಸರ್ವರ್‌ನಲ್ಲಿನ ಲೋಡ್ ಅನ್ನು ಅವಲಂಬಿಸಿ. ಅಂದರೆ, ಸರಾಸರಿ, 101 API ಆಬ್ಜೆಕ್ಟ್‌ಗಳಲ್ಲಿ, ಬ್ಯಾಚ್ ಪ್ರಕಾರದ ಕರೆ 10 ಪಟ್ಟು ವೇಗವಾಗಿ ಚಲಿಸುತ್ತದೆ. ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ವಸ್ತುಗಳ ಮೇಲೆ ವ್ಯತ್ಯಾಸವು ಹೆಚ್ಚು ಪ್ರಭಾವಶಾಲಿಯಾಗಿರುತ್ತದೆ.
ಈಗ ಹೇಗೆ ಕೆಲಸ ಮಾಡಬೇಕೆಂದು ನೋಡೋಣ ಸೆಟ್-ಆಬ್ಜೆಕ್ಟ್ಸ್-ಬ್ಯಾಚ್. ಈ API ಕರೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಯಾವುದೇ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬೃಹತ್ ಪ್ರಮಾಣದಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು. ಹಿಂದಿನ ಉದಾಹರಣೆಯಿಂದ ವಿಳಾಸಗಳ ಮೊದಲಾರ್ಧವನ್ನು (.124 ಹೋಸ್ಟ್‌ಗಳು, ಮತ್ತು ಶ್ರೇಣಿಗಳು ಸಹ) ಬಣ್ಣದ ಸಿಯೆನ್ನಾಕ್ಕೆ ಹೊಂದಿಸೋಣ ಮತ್ತು ವಿಳಾಸಗಳ ದ್ವಿತೀಯಾರ್ಧಕ್ಕೆ ಖಾಕಿ ಬಣ್ಣವನ್ನು ನಿಯೋಜಿಸೋಣ.
ಹಿಂದಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ರಚಿಸಲಾದ ವಸ್ತುಗಳ ಬಣ್ಣವನ್ನು ಬದಲಾಯಿಸುವುದು
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip_first = []
objects_list_range_first = []
objects_list_ip_second = []
objects_list_range_second = []
for ip in range(5,125,5):
data = {"name": f'h_192.168.0.{ip}', "color": "sienna"}
objects_list_ip_first.append(data)
for ip in range(125,255,5):
data = {"name": f'h_192.168.0.{ip}', "color": "khaki"}
objects_list_ip_second.append(data)
first_ip = 1
last_ip = 4
while last_ip < 125:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "color": "sienna"}
objects_list_range_first.append(data)
first_ip+=5
last_ip+=5
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}", "color": "khaki"}
objects_list_range_second.append(data)
first_ip+=5
last_ip+=5
data_for_batch_first = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip_first
}, {
"type" : "address-range",
"list" : objects_list_range_first
}]
}
data_for_batch_second = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip_second
}, {
"type" : "address-range",
"list" : objects_list_range_second
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
set_objects_batch_first = client.api_call("set-objects-batch", data_for_batch_first)
set_objects_batch_second = client.api_call("set-objects-batch", data_for_batch_second)
publish = client.api_call("publish")
ನೀವು ಬಳಸಿಕೊಂಡು ಒಂದು API ಕರೆಯಲ್ಲಿ ಬಹು ವಸ್ತುಗಳನ್ನು ಅಳಿಸಬಹುದು ಡಿಲೀಟ್-ಆಬ್ಜೆಕ್ಟ್ಸ್-ಬ್ಯಾಚ್. ಈ ಹಿಂದೆ ರಚಿಸಲಾದ ಎಲ್ಲಾ ಹೋಸ್ಟ್‌ಗಳನ್ನು ಅಳಿಸುವ ಕೋಡ್ ಉದಾಹರಣೆಯನ್ನು ಈಗ ನೋಡೋಣ ಆಡ್-ಆಬ್ಜೆಕ್ಟ್ಸ್-ಬ್ಯಾಚ್.
ಡಿಲೀಟ್-ಆಬ್ಜೆಕ್ಟ್ಸ್-ಬ್ಯಾಚ್ ಬಳಸಿ ವಸ್ತುಗಳನ್ನು ಅಳಿಸುವುದು
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
objects_list_ip = []
objects_list_range = []
for ip in range(5,255,5):
data = {"name": f'h_192.168.0.{ip}'}
objects_list_ip.append(data)
first_ip = 1
last_ip = 4
while last_ip < 255:
data = {"name": f"r_192.168.0.{first_ip}-{last_ip}"}
objects_list_range.append(data)
first_ip+=5
last_ip+=5
data_for_batch = {
"objects" : [ {
"type" : "host",
"list" : objects_list_ip
}, {
"type" : "address-range",
"list" : objects_list_range
}]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
delete_objects_batch = client.api_call("delete-objects-batch", data_for_batch)
publish = client.api_call("publish")
print(delete_objects_batch.data)
ಚೆಕ್ ಪಾಯಿಂಟ್ ಸಾಫ್ಟ್‌ವೇರ್‌ನ ಹೊಸ ಬಿಡುಗಡೆಗಳಲ್ಲಿ ಗೋಚರಿಸುವ ಎಲ್ಲಾ ಕಾರ್ಯಗಳು ತಕ್ಷಣವೇ API ಕರೆಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತವೆ. ಹೀಗಾಗಿ, R80.40 ನಲ್ಲಿ ಪರಿಷ್ಕರಣೆ ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಕಾರ್ಯಕ್ಕೆ ಹಿಂತಿರುಗಿಸುವಂತಹ "ವೈಶಿಷ್ಟ್ಯಗಳು" ಕಾಣಿಸಿಕೊಂಡವು ಮತ್ತು ಅನುಗುಣವಾದ API ಕರೆಗಳನ್ನು ತಕ್ಷಣವೇ ಸಿದ್ಧಪಡಿಸಲಾಯಿತು. ಇದಲ್ಲದೆ, ಲೆಗಸಿ ಕನ್ಸೋಲ್‌ಗಳಿಂದ ಏಕೀಕೃತ ನೀತಿ ಮೋಡ್‌ಗೆ ಚಲಿಸುವಾಗ ಎಲ್ಲಾ ಕಾರ್ಯಚಟುವಟಿಕೆಗಳು ಸಹ API ಬೆಂಬಲವನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಸಾಫ್ಟ್‌ವೇರ್ ಆವೃತ್ತಿ R80.40 ನಲ್ಲಿನ ಬಹುನಿರೀಕ್ಷಿತ ಅಪ್‌ಡೇಟ್ HTTPS ತಪಾಸಣೆ ನೀತಿಯನ್ನು ಲೆಗಸಿ ಮೋಡ್‌ನಿಂದ ಏಕೀಕೃತ ನೀತಿ ಮೋಡ್‌ಗೆ ಸರಿಸುವುದಾಗಿದೆ ಮತ್ತು ಈ ಕಾರ್ಯವು ತಕ್ಷಣವೇ API ಕರೆಗಳನ್ನು ಸ್ವೀಕರಿಸಿದೆ. HTTPS ತಪಾಸಣೆ ನೀತಿಯ ಉನ್ನತ ಸ್ಥಾನಕ್ಕೆ ನಿಯಮವನ್ನು ಸೇರಿಸುವ ಕೋಡ್‌ನ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ, ಇದು ತಪಾಸಣೆಯಿಂದ 3 ವಿಭಾಗಗಳನ್ನು (ಆರೋಗ್ಯ, ಹಣಕಾಸು, ಸರ್ಕಾರಿ ಸೇವೆಗಳು) ಹೊರತುಪಡಿಸುತ್ತದೆ, ಇವುಗಳನ್ನು ಹಲವಾರು ದೇಶಗಳಲ್ಲಿ ಕಾನೂನಿಗೆ ಅನುಸಾರವಾಗಿ ತಪಾಸಣೆಯಿಂದ ನಿಷೇಧಿಸಲಾಗಿದೆ.
HTTPS ತಪಾಸಣೆ ನೀತಿಗೆ ನಿಯಮವನ್ನು ಸೇರಿಸಿ
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Legal Requirements",
"action": "bypass",
"site-category": ["Health", "Government / Military", "Financial Services"]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
add_https_rule = client.api_call("add-https-rule", data)
publish = client.api_call("publish")
ಚೆಕ್ ಪಾಯಿಂಟ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಸರ್ವರ್ನಲ್ಲಿ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ರನ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಎಲ್ಲವೂ ಒಂದೇ ನಿಯಂತ್ರಣ ಸರ್ವರ್‌ನಿಂದ ನೇರವಾಗಿ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಹೇಗೆ ಚಲಾಯಿಸಬೇಕು ಎಂಬ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ. ನೀವು ಇನ್ನೊಂದು ಯಂತ್ರದಿಂದ API ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದಾಗ ಇದು ಅನುಕೂಲಕರವಾಗಿರುತ್ತದೆ. ನಾನು ಆರು ನಿಮಿಷಗಳ ವೀಡಿಯೊವನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಿದ್ದೇನೆ, ಅದರಲ್ಲಿ ನಾನು ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದನ್ನು ನೋಡುತ್ತೇನೆ cpapi ಮತ್ತು ನಿಯಂತ್ರಣ ಸರ್ವರ್ನಲ್ಲಿ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಚಾಲನೆ ಮಾಡುವ ವೈಶಿಷ್ಟ್ಯಗಳು. ಉದಾಹರಣೆಯಾಗಿ, ನೆಟ್‌ವರ್ಕ್ ಆಡಿಟಿಂಗ್‌ನಂತಹ ಕಾರ್ಯಕ್ಕಾಗಿ ಹೊಸ ಗೇಟ್‌ವೇ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡಲಾಗುತ್ತದೆ ಭದ್ರತಾ ತಪಾಸಣೆ. ನಾನು ವ್ಯವಹರಿಸಬೇಕಾದ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ: ಪೈಥಾನ್ 2.7 ನಲ್ಲಿ ಕಾರ್ಯವು ಇನ್ನೂ ಕಾಣಿಸಿಕೊಂಡಿಲ್ಲ ಇನ್ಪುಟ್, ಆದ್ದರಿಂದ ಬಳಕೆದಾರರು ನಮೂದಿಸುವ ಮಾಹಿತಿಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು, ಒಂದು ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಕಚ್ಚಾ_ಇನ್ಪುಟ್. ಇಲ್ಲದಿದ್ದರೆ, ಕೋಡ್ ಇತರ ಯಂತ್ರಗಳಿಂದ ಪ್ರಾರಂಭಿಸಲು ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಇದು ಕಾರ್ಯವನ್ನು ಬಳಸಲು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ ರೂಟ್ ಆಗಿ_ಲಾಗಿನ್ ಮಾಡಿ, ನಿಮ್ಮ ಸ್ವಂತ ಬಳಕೆದಾರಹೆಸರು, ಪಾಸ್‌ವರ್ಡ್ ಮತ್ತು ನಿರ್ವಹಣಾ ಸರ್ವರ್‌ನ IP ವಿಳಾಸವನ್ನು ಮತ್ತೊಮ್ಮೆ ಸೂಚಿಸದಿರಲು.
ಭದ್ರತಾ ತಪಾಸಣೆಯ ತ್ವರಿತ ಸೆಟಪ್‌ಗಾಗಿ ಸ್ಕ್ರಿಪ್ಟ್
from __future__ import print_function
import getpass
import sys, os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from cpapi import APIClient, APIClientArgs
def main():
with APIClient() as client:
# if client.check_fingerprint() is False:
# print("Could not get the server's fingerprint - Check connectivity with the server.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Login failed:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Enter the gateway name:")
gw_ip = raw_input("Enter the gateway IP address:")
if sys.stdin.isatty():
sic = getpass.getpass("Enter one-time password for the gateway(SIC): ")
else:
print("Attention! Your password will be shown on the screen!")
sic = raw_input("Enter one-time password for the gateway(SIC): ")
version = raw_input("Enter the gateway version(like RXX.YY):")
add_gw = client.api_call("add-simple-gateway", {'name' : gw_name, 'ipv4-address' : gw_ip, 'one-time-password' : sic, 'version': version.capitalize(), 'application-control' : 'true', 'url-filtering' : 'true', 'ips' : 'true', 'anti-bot' : 'true', 'anti-virus' : 'true', 'threat-emulation' : 'true'})
if add_gw.success and add_gw.data['sic-state'] != "communicating":
print("Secure connection with the gateway hasn't established!")
exit(1)
elif add_gw.success:
print("The gateway was added successfully.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Failed to add the gateway - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Network", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("The policy has been changed successfully")
else:
print("Failed to change the policy- {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Cleanup rule", "layer" : "Network", "action": "Accept", "track": {"type": "Detailed Log", "accounting": "true"}})
if change_rule.success:
print("The cleanup rule has been changed successfully")
else:
print("Failed to change the cleanup rule- {}".format(change_rule.error_message))
# publish the result
publish_res = client.api_call("publish", {})
if publish_res.success:
print("The changes were published successfully.")
else:
print("Failed to publish the changes - {}".format(install_tp_policy.error_message))
install_access_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'true', "threat-prevention" : 'false', "targets" : gw_uid})
if install_access_policy.success:
print("The access policy has been installed")
else:
print("Failed to install access policy - {}".format(install_tp_policy.error_message))
install_tp_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'false', "threat-prevention" : 'true', "targets" : gw_uid})
if install_tp_policy.success:
print("The threat prevention policy has been installed")
else:
print("Failed to install threat prevention policy - {}".format(install_tp_policy.error_message))
# add passwords and passphrases to dictionary
with open('additional_pass.conf') as f:
line_num = 0
for line in f:
line_num += 1
add_password_dictionary = client.api_call("run-script", {"script-name" : "Add passwords and passphrases", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("The password dictionary line {} was added successfully".format(line_num))
else:
print("Failed to add the dictionary - {}".format(add_password_dictionary.error_message))
main() ಪಾಸ್‌ವರ್ಡ್ ನಿಘಂಟಿನೊಂದಿಗೆ ಉದಾಹರಣೆ ಫೈಲ್ ಹೆಚ್ಚುವರಿ_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
ತೀರ್ಮಾನಕ್ಕೆ
ಈ ಲೇಖನವು ಕೆಲಸದ ಮೂಲಭೂತ ಸಾಧ್ಯತೆಗಳನ್ನು ಮಾತ್ರ ಪರಿಶೀಲಿಸುತ್ತದೆ ಪೈಥಾನ್ ಎಸ್‌ಡಿಕೆ ಮತ್ತು ಮಾಡ್ಯೂಲ್ cpapi(ನೀವು ಊಹಿಸಿದಂತೆ, ಇವುಗಳು ವಾಸ್ತವವಾಗಿ ಸಮಾನಾರ್ಥಕ ಪದಗಳಾಗಿವೆ), ಮತ್ತು ಈ ಮಾಡ್ಯೂಲ್ನಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಅಧ್ಯಯನ ಮಾಡುವ ಮೂಲಕ ನೀವು ಅದರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಇನ್ನಷ್ಟು ಅವಕಾಶಗಳನ್ನು ಕಂಡುಕೊಳ್ಳುವಿರಿ. ನಿಮ್ಮ ಸ್ವಂತ ತರಗತಿಗಳು, ಕಾರ್ಯಗಳು, ವಿಧಾನಗಳು ಮತ್ತು ಅಸ್ಥಿರಗಳೊಂದಿಗೆ ನೀವು ಅದನ್ನು ಪೂರೈಸಲು ಬಯಸುತ್ತೀರಿ. ನೀವು ಯಾವಾಗಲೂ ನಿಮ್ಮ ಕೆಲಸವನ್ನು ಹಂಚಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ವಿಭಾಗದಲ್ಲಿ ಚೆಕ್ ಪಾಯಿಂಟ್‌ಗಾಗಿ ಇತರ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ವೀಕ್ಷಿಸಬಹುದು ಸಮುದಾಯದಲ್ಲಿ , ಇದು ಉತ್ಪನ್ನ ಡೆವಲಪರ್‌ಗಳು ಮತ್ತು ಬಳಕೆದಾರರಿಬ್ಬರನ್ನೂ ಒಟ್ಟಿಗೆ ತರುತ್ತದೆ.
ಸಂತೋಷದ ಕೋಡಿಂಗ್ ಮತ್ತು ಕೊನೆಯವರೆಗೂ ಓದಿದ್ದಕ್ಕಾಗಿ ಧನ್ಯವಾದಗಳು!
ಮೂಲ: www.habr.com