Python SDK ਨਾਲ ਚੈੱਕ ਪੁਆਇੰਟ API ਨੂੰ ਸਰਲ ਬਣਾਉਣਾ

APIs ਦੇ ਨਾਲ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਦੀ ਪੂਰੀ ਸ਼ਕਤੀ ਉਦੋਂ ਪ੍ਰਗਟ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਦੇ ਨਾਲ ਇੱਕਠੇ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਦੋਂ API ਜਵਾਬਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਲਈ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ API ਬੇਨਤੀਆਂ ਅਤੇ ਟੂਲ ਤਿਆਰ ਕਰਨਾ ਸੰਭਵ ਹੋ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਇਹ ਅਜੇ ਵੀ ਧਿਆਨ ਤੋਂ ਬਾਹਰ ਹੈ ਪਾਈਥਨ ਸਾਫਟਵੇਅਰ ਡਿਵੈਲਪਮੈਂਟ ਕਿੱਟ (ਇਸ ਤੋਂ ਬਾਅਦ ਪਾਈਥਨ SDK ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ) ਲਈ ਪੁਆਇੰਟ ਪ੍ਰਬੰਧਨ API ਦੀ ਜਾਂਚ ਕਰੋ, ਪਰ ਵਿਅਰਥ ਵਿੱਚ. ਇਹ ਡਿਵੈਲਪਰਾਂ ਅਤੇ ਆਟੋਮੇਸ਼ਨ ਦੇ ਉਤਸ਼ਾਹੀਆਂ ਦੇ ਜੀਵਨ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। ਪਾਈਥਨ ਨੇ ਹਾਲ ਹੀ ਵਿੱਚ ਬਹੁਤ ਪ੍ਰਸਿੱਧੀ ਪ੍ਰਾਪਤ ਕੀਤੀ ਹੈ ਅਤੇ ਮੈਂ ਇਸ ਪਾੜੇ ਨੂੰ ਭਰਨ ਅਤੇ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਸਮੀਖਿਆ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਚੈੱਕ ਪੁਆਇੰਟ API ਪਾਈਥਨ ਵਿਕਾਸ ਕਿੱਟ. ਇਹ ਲੇਖ ਹੈਬਰੇ 'ਤੇ ਇਕ ਹੋਰ ਲੇਖ ਵਿਚ ਇਕ ਸ਼ਾਨਦਾਰ ਜੋੜ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ ਚੈੱਕ ਪੁਆਇੰਟ R80.10 API। CLI, ਸਕ੍ਰਿਪਟਾਂ ਅਤੇ ਹੋਰਾਂ ਰਾਹੀਂ ਪ੍ਰਬੰਧਨ. ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਪਾਈਥਨ SDK ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਕ੍ਰਿਪਟਾਂ ਕਿਵੇਂ ਲਿਖਣੀਆਂ ਹਨ ਅਤੇ ਸੰਸਕਰਣ 1.6 (R80.40 ਤੋਂ ਸਮਰਥਿਤ) ਵਿੱਚ ਨਵੀਂ ਪ੍ਰਬੰਧਨ API ਕਾਰਜਕੁਸ਼ਲਤਾ 'ਤੇ ਇੱਕ ਡੂੰਘੀ ਨਜ਼ਰ ਮਾਰਾਂਗੇ। ਲੇਖ ਨੂੰ ਸਮਝਣ ਲਈ, ਤੁਹਾਨੂੰ APIs ਅਤੇ Python ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਬੁਨਿਆਦੀ ਗਿਆਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ।

ਚੈੱਕ ਪੁਆਇੰਟ ਸਰਗਰਮੀ ਨਾਲ 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 - ਨਾਲ ਕੰਮ Dome9

ਪਾਈਥਨ SDK ਵਰਤਮਾਨ ਵਿੱਚ ਸਿਰਫ ਪ੍ਰਬੰਧਨ API ਅਤੇ ਨਾਲ ਗੱਲਬਾਤ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ Gaia API. ਅਸੀਂ ਇਸ ਮੋਡੀਊਲ ਵਿੱਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਕਲਾਸਾਂ, ਵਿਧੀਆਂ ਅਤੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਦੇਖਾਂਗੇ।

ਮੋਡੀਊਲ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨਾ

ਮੋਡੀuleਲ cpapi ਤੋਂ ਤੇਜ਼ੀ ਨਾਲ ਅਤੇ ਆਸਾਨੀ ਨਾਲ ਸਥਾਪਿਤ ਕਰਦਾ ਹੈ github 'ਤੇ ਅਧਿਕਾਰਤ ਚੈੱਕ ਪੁਆਇੰਟ ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਸਹਾਇਤਾ ਨਾਲ PIP. ਵਿਸਤ੍ਰਿਤ ਇੰਸਟਾਲੇਸ਼ਨ ਨਿਰਦੇਸ਼ ਵਿੱਚ ਉਪਲਬਧ ਹਨ README.md. ਇਹ ਮੋਡੀਊਲ ਪਾਈਥਨ ਸੰਸਕਰਣ 2.7 ਅਤੇ 3.7 ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਅਨੁਕੂਲਿਤ ਹੈ। ਇਸ ਲੇਖ ਵਿੱਚ, ਪਾਈਥਨ 3.7 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਦਾਹਰਨਾਂ ਦਿੱਤੀਆਂ ਜਾਣਗੀਆਂ। ਹਾਲਾਂਕਿ, ਪਾਇਥਨ SDK ਨੂੰ ਚੈੱਕ ਪੁਆਇੰਟ ਮੈਨੇਜਮੈਂਟ ਸਰਵਰ (ਸਮਾਰਟ ਮੈਨੇਜਮੈਂਟ) ਤੋਂ ਸਿੱਧਾ ਚਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ ਉਹ ਸਿਰਫ ਪਾਈਥਨ 2.7 ਦਾ ਸਮਰਥਨ ਕਰਦੇ ਹਨ, ਇਸਲਈ ਆਖਰੀ ਭਾਗ ਸੰਸਕਰਣ 2.7 ਲਈ ਕੋਡ ਪ੍ਰਦਾਨ ਕਰੇਗਾ। ਮੋਡੀਊਲ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਤੁਰੰਤ ਬਾਅਦ, ਮੈਂ ਡਾਇਰੈਕਟਰੀਆਂ ਵਿੱਚ ਉਦਾਹਰਣਾਂ ਨੂੰ ਦੇਖਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ example_python2 и example_python3.

ਸ਼ੁਰੂਆਤ

ਸਾਡੇ ਲਈ cpapi ਮੋਡੀਊਲ ਦੇ ਭਾਗਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਸਾਨੂੰ ਮੋਡੀਊਲ ਤੋਂ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ cpapi ਘੱਟੋ-ਘੱਟ ਦੋ ਲੋੜੀਂਦੀਆਂ ਕਲਾਸਾਂ:

APIClient и APIClientArgs

from cpapi import APIClient, APIClientArgs

Класс APIClientArgs API ਸਰਵਰ, ਅਤੇ ਕਲਾਸ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਪੈਰਾਮੀਟਰਾਂ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ APIClient 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 = context

ਮੇਰਾ ਮੰਨਣਾ ਹੈ ਕਿ APIClientArgs ਕਲਾਸ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਵਰਤੇ ਜਾ ਸਕਣ ਵਾਲੇ ਆਰਗੂਮੈਂਟ ਚੈਕ ਪੁਆਇੰਟ ਪ੍ਰਸ਼ਾਸਕਾਂ ਲਈ ਅਨੁਭਵੀ ਹਨ ਅਤੇ ਵਾਧੂ ਟਿੱਪਣੀਆਂ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।

APIClient ਅਤੇ ਸੰਦਰਭ ਪ੍ਰਬੰਧਕ ਰਾਹੀਂ ਜੁੜ ਰਿਹਾ ਹੈ

Класс APIClient ਇਸਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕਾ ਸੰਦਰਭ ਪ੍ਰਬੰਧਕ ਦੁਆਰਾ ਹੈ। 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)

ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਭਵਿੱਖ ਵਿੱਚ ਕਲਾਸ APIClient ਹਰੇਕ API ਕਾਲ ਦੀ ਜਾਂਚ ਕਰੇਗਾ (ਤਰੀਕਿਆਂ api_ਕਾਲ и api_query, ਅਸੀਂ ਉਹਨਾਂ ਬਾਰੇ ਥੋੜਾ ਹੋਰ ਅੱਗੇ ਗੱਲ ਕਰਾਂਗੇ) API ਸਰਵਰ 'ਤੇ sha1 ਫਿੰਗਰਪ੍ਰਿੰਟ ਸਰਟੀਫਿਕੇਟ. ਪਰ ਜੇਕਰ, API ਸਰਵਰ ਸਰਟੀਫਿਕੇਟ ਦੇ sha1 ਫਿੰਗਰਪ੍ਰਿੰਟ ਦੀ ਜਾਂਚ ਕਰਦੇ ਸਮੇਂ, ਇੱਕ ਗਲਤੀ ਦਾ ਪਤਾ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ (ਸਰਟੀਫਿਕੇਟ ਅਣਜਾਣ ਹੈ ਜਾਂ ਬਦਲਿਆ ਗਿਆ ਹੈ), ਵਿਧੀ ਚੈੱਕ_ਫਿੰਗਰਪ੍ਰਿੰਟ ਸਥਾਨਕ ਮਸ਼ੀਨ 'ਤੇ ਆਪਣੇ ਆਪ ਇਸ ਬਾਰੇ ਜਾਣਕਾਰੀ ਜੋੜਨ/ਬਦਲਣ ਦਾ ਮੌਕਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ। ਇਸ ਜਾਂਚ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਯੋਗ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਪਰ ਇਸਦੀ ਸਿਫ਼ਾਰਸ਼ ਸਿਰਫ਼ ਤਾਂ ਹੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜੇਕਰ 127.0.0.1 ਨਾਲ ਕਨੈਕਟ ਕਰਨ ਵੇਲੇ, API ਸਰਵਰ ਉੱਤੇ ਸਕ੍ਰਿਪਟਾਂ ਚਲਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ), APIClientArgs ਆਰਗੂਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ - ਅਸੁਰੱਖਿਅਤ_ਆਟੋ_ਸਵੀਕਾਰ ("ਕੁਨੈਕਸ਼ਨ ਪੈਰਾਮੀਟਰ ਪਰਿਭਾਸ਼ਿਤ" ਵਿੱਚ APIClientArgs ਬਾਰੇ ਹੋਰ ਦੇਖੋ)।

client_args = APIClientArgs(unsafe_auto_accept=True)

API ਸਰਵਰ ਤੇ ਲੌਗਇਨ ਕਰੋ

У APIClient API ਸਰਵਰ ਵਿੱਚ ਲੌਗਇਨ ਕਰਨ ਲਈ 3 ਤਰੀਕੇ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਦਾ ਮਤਲਬ ਸਮਝਦਾ ਹੈ sid(ਸ਼ੈਸ਼ਨ-ਆਈਡੀ), ਜੋ ਕਿ ਸਿਰਲੇਖ ਵਿੱਚ ਹਰੇਕ ਅਗਲੀ API ਕਾਲ ਵਿੱਚ ਆਪਣੇ ਆਪ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ (ਇਸ ਪੈਰਾਮੀਟਰ ਦੇ ਸਿਰਲੇਖ ਵਿੱਚ ਨਾਮ ਹੈ X-chkp-sid), ਇਸ ਲਈ ਇਸ ਪੈਰਾਮੀਟਰ ਨੂੰ ਅੱਗੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।

ਲਾਗਇਨ ਢੰਗ

ਲੌਗਇਨ ਅਤੇ ਪਾਸਵਰਡ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਵਿਕਲਪ (ਉਦਾਹਰਨ ਵਿੱਚ, ਯੂਜ਼ਰਨੇਮ ਐਡਮਿਨ ਅਤੇ ਪਾਸਵਰਡ 1q2w3e ਸਥਿਤੀ ਸੰਬੰਧੀ ਆਰਗੂਮੈਂਟਾਂ ਵਜੋਂ ਪਾਸ ਕੀਤੇ ਗਏ ਹਨ):

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

ਲੌਗਇਨ ਵਿਧੀ ਵਿੱਚ ਵਾਧੂ ਵਿਕਲਪਿਕ ਮਾਪਦੰਡ ਵੀ ਉਪਲਬਧ ਹਨ; ਇੱਥੇ ਉਹਨਾਂ ਦੇ ਨਾਮ ਅਤੇ ਮੂਲ ਮੁੱਲ ਹਨ:

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

ਲੌਗਇਨ_ਵਿਦ_ਏਪੀਆਈ_ਕੀ ਵਿਧੀ

ਏਪੀਆਈ ਕੁੰਜੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਵਿਕਲਪ (ਪ੍ਰਬੰਧਨ ਸੰਸਕਰਣ R80.40/ਪ੍ਰਬੰਧਨ API v1.6 ਤੋਂ ਸ਼ੁਰੂ ਕਰਕੇ ਸਮਰਥਿਤ, "3TsbPJ8ZKjaJGvFyoFqHFA==" ਇਹ API ਕੁੰਜੀ ਪ੍ਰਮਾਣੀਕਰਨ ਵਿਧੀ ਨਾਲ ਪ੍ਰਬੰਧਨ ਸਰਵਰ 'ਤੇ ਉਪਭੋਗਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਲਈ API ਕੁੰਜੀ ਮੁੱਲ ਹੈ):

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

ਵਿਧੀ ਵਿੱਚ login_with_api_key ਉਹੀ ਵਿਕਲਪਿਕ ਪੈਰਾਮੀਟਰ ਉਪਲਬਧ ਹਨ ਜਿਵੇਂ ਕਿ ਵਿਧੀ ਵਿੱਚ ਲਾਗਿਨ.

login_as_root ਵਿਧੀ

ਇੱਕ API ਸਰਵਰ ਨਾਲ ਇੱਕ ਸਥਾਨਕ ਮਸ਼ੀਨ ਵਿੱਚ ਲੌਗਇਨ ਕਰਨ ਦਾ ਵਿਕਲਪ:

     login = client.login_as_root()

ਇਸ ਵਿਧੀ ਲਈ ਸਿਰਫ਼ ਦੋ ਵਿਕਲਪਿਕ ਮਾਪਦੰਡ ਉਪਲਬਧ ਹਨ:

domain=None, payload=None

ਅਤੇ ਅੰਤ ਵਿੱਚ API ਆਪਣੇ ਆਪ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ

ਸਾਡੇ ਕੋਲ ਤਰੀਕਿਆਂ ਰਾਹੀਂ API ਕਾਲਾਂ ਕਰਨ ਲਈ ਦੋ ਵਿਕਲਪ ਹਨ api_ਕਾਲ и api_query. ਆਓ ਇਹ ਪਤਾ ਕਰੀਏ ਕਿ ਉਹਨਾਂ ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ.

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 ਕਾਲਾਂ ਦੇ ਨਤੀਜਿਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰ ਰਿਹਾ ਹੈ

ਇਸ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਕਲਾਸ ਦੇ ਵੇਰੀਏਬਲ ਅਤੇ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ APIਜਵਾਬ(ਦੋਵੇਂ ਸੰਦਰਭ ਪ੍ਰਬੰਧਕ ਦੇ ਅੰਦਰ ਅਤੇ ਬਾਹਰ)। ਕਲਾਸ 'ਤੇ APIਜਵਾਬ 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.

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

ਜਵਾਬ()

ਜਵਾਬ ਵਿਧੀ ਤੁਹਾਨੂੰ ਜਵਾਬ ਕੋਡ (ਸਟੇਟਸ_ਕੋਡ) ਅਤੇ ਜਵਾਬ ਦੇ ਭਾਗ (ਸਰੀਰ) ਦੇ ਨਾਲ ਸ਼ਬਦਕੋਸ਼ ਨੂੰ ਦੇਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।

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 ਕਾਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ ਜੋ ਪ੍ਰਬੰਧਨ API 1.6 ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਗਈਆਂ ਸਨ।

ਪਹਿਲਾਂ, ਆਓ ਦੇਖੀਏ ਕਿ ਕਾਲਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ ਐਡ-ਹੋਸਟ и ਐਡ-ਐਡਰੈੱਸ-ਰੇਂਜ. ਮੰਨ ਲਓ ਕਿ ਸਾਨੂੰ ਸਬਨੈੱਟ 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 ਕਾਲ ਦੇ ਢਾਂਚੇ ਦੇ ਅੰਦਰ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਐਡ-ਆਬਜੈਕਟਸ-ਬੈਚ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਕ੍ਰਿਪਟ

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 ਕਾਲ ਵਿੱਚ ਕਈ ਵਸਤੂਆਂ ਨੂੰ ਮਿਟਾ ਸਕਦੇ ਹੋ ਡਿਲੀਟ-ਆਬਜੈਕਟਸ-ਬੈਚ. ਹੁਣ ਆਉ ਇੱਕ ਕੋਡ ਉਦਾਹਰਨ ਵੇਖੀਏ ਜੋ ਪਹਿਲਾਂ ਦੁਆਰਾ ਬਣਾਏ ਗਏ ਸਾਰੇ ਮੇਜ਼ਬਾਨਾਂ ਨੂੰ ਮਿਟਾ ਦਿੰਦਾ ਹੈ 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 ਵਿੱਚ ਪ੍ਰਗਟ ਨਹੀਂ ਹੋਇਆ ਹੈ ਇੰਪੁੱਟ, ਇਸ ਲਈ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਦਾਖਲ ਕੀਤੀ ਗਈ ਜਾਣਕਾਰੀ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ, ਇੱਕ ਫੰਕਸ਼ਨ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ raw_input. ਨਹੀਂ ਤਾਂ, ਕੋਡ ਦੂਜੀਆਂ ਮਸ਼ੀਨਾਂ ਤੋਂ ਲਾਂਚ ਕਰਨ ਦੇ ਸਮਾਨ ਹੈ, ਸਿਰਫ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਵਧੇਰੇ ਸੁਵਿਧਾਜਨਕ ਹੈ login_as_root, ਤਾਂ ਕਿ ਪ੍ਰਬੰਧਨ ਸਰਵਰ ਦਾ ਆਪਣਾ ਉਪਭੋਗਤਾ ਨਾਮ, ਪਾਸਵਰਡ ਅਤੇ 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