പൈത്തൺ SDK ഉപയോഗിച്ച് ചെക്ക് പോയിന്റ് API ലളിതമാക്കുന്നു

API അഭ്യർത്ഥനകളും API പ്രതികരണങ്ങൾ വിശകലനം ചെയ്യുന്നതിനുള്ള ഉപകരണങ്ങളും ചലനാത്മകമായി ജനറേറ്റുചെയ്യുന്നത് സാധ്യമാകുമ്പോൾ, പ്രോഗ്രാം കോഡിനൊപ്പം ഉപയോഗിക്കുമ്പോൾ API-കളുമായുള്ള ആശയവിനിമയത്തിന്റെ പൂർണ്ണ ശക്തി വെളിപ്പെടും. എന്നിരുന്നാലും, അത് ഇപ്പോഴും ശ്രദ്ധിക്കപ്പെടാതെ തുടരുന്നു പൈത്തൺ സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെന്റ് കിറ്റ് (ഇനി മുതൽ പൈത്തൺ SDK എന്ന് വിളിക്കുന്നു) എന്നതിനായി പോയിന്റ് മാനേജ്മെന്റ് API പരിശോധിക്കുക, പക്ഷേ വെറുതെ. ഇത് ഡവലപ്പർമാരുടെയും ഓട്ടോമേഷൻ പ്രേമികളുടെയും ജീവിതത്തെ ഗണ്യമായി ലളിതമാക്കുന്നു. പൈത്തണിന് ഈയിടെ വലിയ ജനപ്രീതി ലഭിച്ചു, ഈ വിടവ് നികത്താനും പ്രധാന സവിശേഷതകൾ അവലോകനം ചെയ്യാനും ഞാൻ തീരുമാനിച്ചു. ചെക്ക് പോയിന്റ് API പൈത്തൺ വികസന കിറ്റ്. ഈ ലേഖനം ഹബ്രെയെക്കുറിച്ചുള്ള മറ്റൊരു ലേഖനത്തിന്റെ മികച്ച കൂട്ടിച്ചേർക്കലായി വർത്തിക്കുന്നു ചെക്ക് പോയിന്റ് R80.10 API. CLI, സ്ക്രിപ്റ്റുകൾ എന്നിവയും മറ്റും വഴിയുള്ള മാനേജ്മെന്റ്. പൈത്തൺ SDK ഉപയോഗിച്ച് സ്ക്രിപ്റ്റുകൾ എങ്ങനെ എഴുതാമെന്നും പതിപ്പ് 1.6-ലെ (R80.40 മുതൽ പിന്തുണയ്‌ക്കുന്ന) പുതിയ മാനേജ്‌മെന്റ് API പ്രവർത്തനത്തെ സൂക്ഷ്മമായി പരിശോധിക്കാമെന്നും ഞങ്ങൾ നോക്കും. ലേഖനം മനസിലാക്കാൻ, API-കളും പൈത്തണും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള അടിസ്ഥാന അറിവ് നിങ്ങൾക്ക് ആവശ്യമാണ്.

ചെക്ക് പോയിന്റ് സജീവമായി API വികസിപ്പിക്കുന്നു, ഇപ്പോൾ ഇനിപ്പറയുന്നവ റിലീസ് ചെയ്‌തു:

• പോയിന്റ് മാനേജ്മെന്റ് API പരിശോധിക്കുക (നിലവിലെ പതിപ്പ് 1.6) - API വഴി കൺട്രോൾ സെർവറുമായി പ്രവർത്തിക്കുക (കൂടാതെ കൺട്രോൾ സെർവർ നിയന്ത്രിക്കുന്ന ഗേറ്റ്‌വേകളിൽ സ്ക്രിപ്റ്റുകൾ എക്സിക്യൂട്ട് ചെയ്യാനുള്ള കഴിവും)
• ചെക്ക് പോയിന്റ് GAIA API (നിലവിലെ പതിപ്പ് 1.4) - സുരക്ഷാ ഗേറ്റ്‌വേകളിൽ പ്രവർത്തിക്കുക
• ഭീഷണി തടയൽ API 1.0 — ചെക്ക് പോയിന്റ് ക്ലൗഡിൽ ഒരു സാൻഡ്ബോക്സിൽ പ്രവർത്തിക്കുന്നു
• ഐഡന്റിറ്റി അവയർനസ് API - ഗേറ്റ്‌വേകളിൽ ഐഡന്റിറ്റി അവയർനസ് ബ്ലേഡുമായി പ്രവർത്തിക്കുന്നു
• സുരക്ഷാ മാനേജ്മെന്റ് പോർട്ടൽ API - SMB ഗേറ്റ്‌വേ മാനേജ്‌മെന്റ് പോർട്ടലുമായി പ്രവർത്തിക്കുക (SMB ഗേറ്റ്‌വേകളെക്കുറിച്ച് കൂടുതൽ)
• IoT API - IoT കൺട്രോളറുകളുമായുള്ള ഇടപെടൽ
• CloudGuard കണക്റ്റ് API - കൂടെ ജോലി CloudGuard കണക്റ്റ് (SD-WAN സുരക്ഷാ പരിഹാരം)
• Dome9 API - കൂടെ ജോലി ഡോം9

പൈത്തൺ SDK നിലവിൽ മാനേജ്മെന്റ് API യുമായുള്ള ആശയവിനിമയത്തെ പിന്തുണയ്ക്കുന്നു Gaia API. ഈ മൊഡ്യൂളിലെ ഏറ്റവും പ്രധാനപ്പെട്ട ക്ലാസുകളും രീതികളും വേരിയബിളുകളും ഞങ്ങൾ നോക്കും.

മൊഡ്യൂൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു

Дульодуль cpapi വേഗത്തിലും എളുപ്പത്തിലും ഇൻസ്റ്റാൾ ചെയ്യുന്നു github-ലെ ഔദ്യോഗിക ചെക്ക് പോയിന്റ് ശേഖരം സഹായത്തോടെ PIP. വിശദമായ ഇൻസ്റ്റാളേഷൻ നിർദ്ദേശങ്ങൾ ലഭ്യമാണ് README.md. ഈ മൊഡ്യൂൾ പൈത്തൺ പതിപ്പുകൾ 2.7, 3.7 എന്നിവയിൽ പ്രവർത്തിക്കാൻ അനുയോജ്യമാണ്. ഈ ലേഖനത്തിൽ, പൈത്തൺ 3.7 ഉപയോഗിച്ച് ഉദാഹരണങ്ങൾ നൽകും. എന്നിരുന്നാലും, പൈത്തൺ SDK ചെക്ക് പോയിന്റ് മാനേജ്മെന്റ് സെർവറിൽ (സ്മാർട്ട് മാനേജ്മെന്റ്) നിന്ന് നേരിട്ട് പ്രവർത്തിപ്പിക്കാൻ കഴിയും, എന്നാൽ അവ പൈത്തൺ 2.7 നെ മാത്രമേ പിന്തുണയ്ക്കൂ, അതിനാൽ അവസാന ഭാഗം പതിപ്പ് 2.7-നുള്ള കോഡ് നൽകും. മൊഡ്യൂൾ ഇൻസ്റ്റാൾ ചെയ്ത ഉടനെ, ഡയറക്ടറികളിലെ ഉദാഹരണങ്ങൾ നോക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു ഉദാഹരണങ്ങൾ_പൈത്തൺ2 и ഉദാഹരണങ്ങൾ_പൈത്തൺ3.

ആരംഭിക്കുന്നു

cpapi മൊഡ്യൂളിന്റെ ഘടകങ്ങളുമായി പ്രവർത്തിക്കാൻ ഞങ്ങൾക്ക്, മൊഡ്യൂളിൽ നിന്ന് ഇറക്കുമതി ചെയ്യേണ്ടതുണ്ട്. cpapi കുറഞ്ഞത് രണ്ട് ആവശ്യമായ ക്ലാസുകളെങ്കിലും:

APClient и APIClientArgs

from cpapi import APIClient, APIClientArgs

ക്ലാസ് APIClientArgs API സെർവറിലേക്കും ക്ലാസിലേക്കും കണക്ഷൻ പാരാമീറ്ററുകൾക്ക് ഉത്തരവാദിത്തമുണ്ട് APClient API-യുമായുള്ള ആശയവിനിമയത്തിന്റെ ഉത്തരവാദിത്തം.

കണക്ഷൻ പാരാമീറ്ററുകൾ നിർണ്ണയിക്കുന്നു

API-യിലേക്ക് കണക്റ്റുചെയ്യുന്നതിനുള്ള വിവിധ പാരാമീറ്ററുകൾ നിർവചിക്കുന്നതിന്, നിങ്ങൾ ക്ലാസിന്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കേണ്ടതുണ്ട് APIClientArgs. തത്വത്തിൽ, അതിന്റെ പാരാമീറ്ററുകൾ മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടുണ്ട്, നിയന്ത്രണ സെർവറിൽ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ, അവ വ്യക്തമാക്കേണ്ടതില്ല.

client_args = APIClientArgs()

എന്നാൽ ഒരു മൂന്നാം കക്ഷി ഹോസ്റ്റിൽ പ്രവർത്തിക്കുമ്പോൾ, API സെർവറിന്റെ (മാനേജ്മെന്റ് സെർവർ എന്നും അറിയപ്പെടുന്നു) കുറഞ്ഞത് IP വിലാസമോ ഹോസ്റ്റ് നാമമോ നിങ്ങൾ വ്യക്തമാക്കേണ്ടതുണ്ട്. ചുവടെയുള്ള ഉദാഹരണത്തിൽ, ഞങ്ങൾ സെർവർ കണക്ഷൻ പാരാമീറ്റർ നിർവ്വചിക്കുകയും മാനേജ്മെന്റ് സെർവറിന്റെ 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 = context

APIClientArgs ക്ലാസിന്റെ സന്ദർഭങ്ങളിൽ ഉപയോഗിക്കാവുന്ന ആർഗ്യുമെന്റുകൾ ചെക്ക് പോയിന്റ് അഡ്മിനിസ്ട്രേറ്റർമാർക്ക് അവബോധജന്യമാണെന്നും അധിക അഭിപ്രായങ്ങൾ ആവശ്യമില്ലെന്നും ഞാൻ വിശ്വസിക്കുന്നു.

APClient വഴിയും സന്ദർഭ മാനേജർ വഴിയും ബന്ധിപ്പിക്കുന്നു

ക്ലാസ് 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)

ഭാവിയിൽ ക്ലാസ് എന്നത് ശ്രദ്ധിക്കുക APClient ഓരോ API കോളും പരിശോധിക്കും (രീതികൾ api_call и api_query, ഞങ്ങൾ അവയെക്കുറിച്ച് കുറച്ചുകൂടി സംസാരിക്കും) API സെർവറിലെ sha1 ഫിംഗർപ്രിന്റ് സർട്ടിഫിക്കറ്റ്. എന്നാൽ, API സെർവർ സർട്ടിഫിക്കറ്റിന്റെ sha1 ഫിംഗർപ്രിന്റ് പരിശോധിക്കുമ്പോൾ, ഒരു പിശക് കണ്ടെത്തിയാൽ (സർട്ടിഫിക്കറ്റ് അജ്ഞാതമാണ് അല്ലെങ്കിൽ മാറ്റിയിരിക്കുന്നു), രീതി ചെക്ക്_ഫിംഗർപ്രിന്റ് ലോക്കൽ മെഷീനിൽ അതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ സ്വയമേവ ചേർക്കാനും മാറ്റാനും അവസരം നൽകും. ഈ പരിശോധന പൂർണ്ണമായും പ്രവർത്തനരഹിതമാക്കാൻ കഴിയും (എന്നാൽ 127.0.0.1 ലേക്ക് കണക്‌റ്റ് ചെയ്യുമ്പോൾ, API സെർവറിൽ തന്നെ സ്‌ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ മാത്രമേ ഇത് ശുപാർശ ചെയ്യാൻ കഴിയൂ), APIClientArgs ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് - സുരക്ഷിതമല്ലാത്ത_സ്വയം_അംഗീകരിക്കുക ("കണക്ഷൻ പാരാമീറ്ററുകൾ നിർവചിക്കുന്നു" എന്നതിൽ നേരത്തെ APIClientArgs-നെ കുറിച്ച് കൂടുതൽ കാണുക).

client_args = APIClientArgs(unsafe_auto_accept=True)

API സെർവറിലേക്ക് ലോഗിൻ ചെയ്യുക

У APClient API സെർവറിലേക്ക് ലോഗിൻ ചെയ്യുന്നതിന് 3 രീതികൾ ഉണ്ട്, അവ ഓരോന്നും അർത്ഥം മനസ്സിലാക്കുന്നു സിഡ്(സെഷൻ-ഐഡി), ഇത് ഹെഡറിലെ ഓരോ തുടർന്നുള്ള എപിഐ കോളിലും സ്വയമേവ ഉപയോഗിക്കുന്നു (ഈ പരാമീറ്ററിന്റെ തലക്കെട്ടിലെ പേര് X-chkp-sid), അതിനാൽ ഈ പരാമീറ്റർ കൂടുതൽ പ്രോസസ്സ് ചെയ്യേണ്ട ആവശ്യമില്ല.

ലോഗിൻ രീതി

ലോഗിനും പാസ്‌വേഡും ഉപയോഗിക്കുന്ന ഓപ്ഷൻ (ഉദാഹരണത്തിൽ, ഉപയോക്തൃനാമവും അഡ്മിൻ പാസ്‌വേഡും 1q2w3e പൊസിഷണൽ ആർഗ്യുമെന്റുകളായി കൈമാറുന്നു):

     login = client.login('admin', '1q2w3e')  

ലോഗിൻ രീതിയിൽ അധിക ഓപ്‌ഷണൽ പാരാമീറ്ററുകളും ലഭ്യമാണ്; അവയുടെ പേരുകളും ഡിഫോൾട്ട് മൂല്യങ്ങളും ഇവിടെയുണ്ട്:

continue_last_session=False, domain=None, read_only=False, payload=None

Api_key രീതി ഉപയോഗിച്ച്_ലോഗിൻ ചെയ്യുക

ഒരു എപിഐ കീ ഉപയോഗിക്കുന്ന ഓപ്ഷൻ (മാനേജ്മെന്റ് പതിപ്പ് R80.40/മാനേജ്മെന്റ് API v1.6 മുതൽ പിന്തുണയ്ക്കുന്നു, "3TsbPJ8ZKjaJGvFyoFqHFA==" API കീ അംഗീകാര രീതിയുള്ള മാനേജ്മെന്റ് സെർവറിലെ ഉപയോക്താക്കളിൽ ഒരാളുടെ API കീ മൂല്യമാണിത്:

     login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') 

രീതിയിലാണ് api_key ഉപയോഗിച്ച്_ലോഗിൻ ചെയ്യുക രീതിയിലുള്ള അതേ ഓപ്ഷണൽ പാരാമീറ്ററുകൾ ലഭ്യമാണ് ലോഗിൻ.

ലോഗിൻ_ആസ്_റൂട്ട് രീതി

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 കോൾ വിജയകരമാണെങ്കിൽ True നൽകുന്നു (പ്രതികരണ കോഡ് - 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.

set_success_status

ഈ സാഹചര്യത്തിൽ, വിജയ നിലയുടെ മൂല്യം മാറ്റേണ്ടത് ആവശ്യമായി വന്നേക്കാം. സാങ്കേതികമായി, നിങ്ങൾക്ക് അവിടെ എന്തും സ്ഥാപിക്കാം, ഒരു സാധാരണ സ്ട്രിംഗ് പോലും. എന്നാൽ ഒരു യഥാർത്ഥ ഉദാഹരണം ചില അനുബന്ധ വ്യവസ്ഥകളിൽ ഈ പരാമീറ്റർ തെറ്റിലേക്ക് പുനഃസജ്ജമാക്കുന്നതാണ്. താഴെ, മാനേജ്മെന്റ് സെർവറിൽ ടാസ്ക്കുകൾ പ്രവർത്തിക്കുമ്പോൾ ഉദാഹരണം ശ്രദ്ധിക്കുക, എന്നാൽ ഈ അഭ്യർത്ഥന പരാജയപ്പെട്ടതായി ഞങ്ങൾ പരിഗണിക്കും (ഞങ്ങൾ വിജയ വേരിയബിൾ സജ്ജമാക്കും തെറ്റായ, 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 കോൾ ഉപയോഗിച്ച് അതേ പ്രശ്നം എങ്ങനെ പരിഹരിക്കാമെന്ന് നോക്കാം add-objects-batch, API പതിപ്പ് 1.6-ൽ ഇതിനുള്ള പിന്തുണ ചേർത്തു. ഒരു API അഭ്യർത്ഥനയിൽ ഒരേസമയം നിരവധി ഒബ്‌ജക്റ്റുകൾ സൃഷ്‌ടിക്കാൻ ഈ കോൾ നിങ്ങളെ അനുവദിക്കുന്നു. മാത്രമല്ല, ഇവ വ്യത്യസ്ത തരത്തിലുള്ള ഒബ്‌ജക്റ്റുകളാകാം (ഉദാഹരണത്തിന്, ഹോസ്റ്റുകൾ, സബ്‌നെറ്റുകൾ, വിലാസ ശ്രേണികൾ). അങ്ങനെ, ഞങ്ങളുടെ ചുമതല ഒരു API കോളിന്റെ ചട്ടക്കൂടിനുള്ളിൽ പരിഹരിക്കാൻ കഴിയും.

add-objects-batch ഉപയോഗിച്ച് സ്ക്രിപ്റ്റ്

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 മടങ്ങ് വേഗത്തിൽ പ്രവർത്തിക്കുന്നു. ഒബ്‌ജക്റ്റുകളുടെ ഒരു വലിയ സംഖ്യയിൽ, വ്യത്യാസം കൂടുതൽ ശ്രദ്ധേയമായിരിക്കും.

ഇപ്പോൾ എങ്ങനെ പ്രവർത്തിക്കാമെന്ന് നോക്കാം set-objects-batch. ഈ 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 കോളിൽ ഒന്നിലധികം ഒബ്‌ജക്‌റ്റുകൾ ഇല്ലാതാക്കാം delete-objects-batch. മുമ്പ് സൃഷ്ടിച്ച എല്ലാ ഹോസ്റ്റുകളെയും ഇല്ലാതാക്കുന്ന ഒരു കോഡ് ഉദാഹരണം നോക്കാം add-objects-batch.

ഡിലീറ്റ്-ഒബ്ജക്റ്റ്സ്-ബാച്ച് ഉപയോഗിച്ച് ഒബ്ജക്റ്റുകൾ ഇല്ലാതാക്കുന്നു

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")

ചെക്ക് പോയിന്റ് മാനേജ്മെന്റ് സെർവറിൽ പൈത്തൺ സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നു

എല്ലാം ഒന്നുതന്നെ README.md കൺട്രോൾ സെർവറിൽ നിന്ന് നേരിട്ട് പൈത്തൺ സ്ക്രിപ്റ്റുകൾ എങ്ങനെ പ്രവർത്തിപ്പിക്കാം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു. നിങ്ങൾക്ക് മറ്റൊരു മെഷീനിൽ നിന്ന് 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()

ഒരു പാസ്‌വേഡ് നിഘണ്ടു കൂടിയുള്ള ഒരു ഉദാഹരണ ഫയൽ added_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

തീരുമാനം

ഈ ലേഖനം ജോലിയുടെ അടിസ്ഥാന സാധ്യതകൾ മാത്രം പരിശോധിക്കുന്നു പൈത്തൺ SDK മൊഡ്യൂളും cpapi(നിങ്ങൾ ഊഹിച്ചതുപോലെ, ഇവ യഥാർത്ഥത്തിൽ പര്യായങ്ങളാണ്), കൂടാതെ ഈ മൊഡ്യൂളിലെ കോഡ് പഠിക്കുന്നതിലൂടെ, അതിനോടൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള കൂടുതൽ സാധ്യതകൾ നിങ്ങൾ കണ്ടെത്തും. നിങ്ങളുടെ സ്വന്തം ക്ലാസുകൾ, ഫംഗ്‌ഷനുകൾ, രീതികൾ, വേരിയബിളുകൾ എന്നിവയ്‌ക്കൊപ്പം ഇത് സപ്ലിമെന്റ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുണ്ടാകാം. വിഭാഗത്തിലെ ചെക്ക് പോയിന്റിനായി നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും നിങ്ങളുടെ ജോലി പങ്കിടാനും മറ്റ് സ്ക്രിപ്റ്റുകൾ കാണാനും കഴിയും കോഡ്ഹബ് സമൂഹത്തിൽ ചെക്ക്മേറ്റ്സ്, ഇത് ഉൽപ്പന്ന ഡെവലപ്പർമാരെയും ഉപയോക്താക്കളെയും ഒരുമിച്ച് കൊണ്ടുവരുന്നു.

സന്തോഷകരമായ കോഡിംഗും അവസാനം വരെ വായിച്ചതിന് നന്ദി!

അവലംബം: www.habr.com