ការធ្វើឱ្យសាមញ្ញនូវ Check Point API ជាមួយ Python SDK

ថាមពលពេញលេញនៃអន្តរកម្មជាមួយ APIs ត្រូវបានបង្ហាញនៅពេលប្រើរួមគ្នាជាមួយកូដកម្មវិធី នៅពេលដែលវាអាចធ្វើទៅបានដើម្បីបង្កើតសំណើ API និងឧបករណ៍សម្រាប់វិភាគការឆ្លើយតប API ។ ទោះយ៉ាងណាក៏ដោយ វានៅតែមិនអាចកត់សម្គាល់បាន។ កញ្ចប់អភិវឌ្ឍន៍កម្មវិធី Python (តទៅនេះហៅថា Python SDK) សម្រាប់ ពិនិត្យចំណុចគ្រប់គ្រង APIប៉ុន្តែនៅក្នុងឥតប្រយោជន៍។ វាជួយសម្រួលដល់ជីវិតរបស់អ្នកអភិវឌ្ឍន៍ និងអ្នកចូលចិត្តស្វ័យប្រវត្តិកម្មយ៉ាងងាយស្រួល។ Python ទទួលបានប្រជាប្រិយភាពយ៉ាងខ្លាំងនាពេលថ្មីៗនេះ ហើយខ្ញុំបានសម្រេចចិត្តបំពេញចន្លោះ និងពិនិត្យមើលលក្ខណៈសំខាន់ៗ។ ពិនិត្យចំណុច API កញ្ចប់អភិវឌ្ឍន៍ Python. អត្ថបទនេះបម្រើជាការបន្ថែមដ៏ល្អចំពោះអត្ថបទមួយទៀតនៅលើ Habre ពិនិត្យចំណុច R80.10 API ។ ការគ្រប់គ្រងតាមរយៈ CLI ស្គ្រីប និងច្រើនទៀត. យើងនឹងពិនិត្យមើលរបៀបសរសេរស្គ្រីបដោយប្រើ Python SDK ហើយពិនិត្យមើលឱ្យកាន់តែច្បាស់អំពីមុខងារគ្រប់គ្រង API ថ្មីនៅក្នុងកំណែ 1.6 (គាំទ្រចាប់ពី R80.40)។ ដើម្បីយល់ពីអត្ថបទ អ្នកនឹងត្រូវការចំណេះដឹងជាមូលដ្ឋានក្នុងការធ្វើការជាមួយ APIs និង Python ។

Check Point កំពុងអភិវឌ្ឍ API យ៉ាងសកម្ម ហើយនៅពេលនេះ ខាងក្រោមនេះត្រូវបានចេញផ្សាយ៖

• Check Point Management API (កំណែបច្ចុប្បន្ន 1.6) - ធ្វើការជាមួយម៉ាស៊ីនមេត្រួតពិនិត្យតាមរយៈ API (និងសមត្ថភាពក្នុងការប្រតិបត្តិស្គ្រីបនៅលើច្រកផ្លូវដែលគ្រប់គ្រងដោយម៉ាស៊ីនមេត្រួតពិនិត្យ)
• Check Point GAIA API (កំណែបច្ចុប្បន្ន 1.4) - ធ្វើការជាមួយច្រកទ្វារសុវត្ថិភាព
• ការការពារការគំរាមកំហែង API 1.0 - ធ្វើការជាមួយប្រអប់ខ្សាច់នៅក្នុង Check Point cloud
• API ការយល់ដឹងអំពីអត្តសញ្ញាណ - ធ្វើការជាមួយ blade ការយល់ដឹងអំពីអត្តសញ្ញាណនៅលើច្រកផ្លូវ
• API វិបផតថលគ្រប់គ្រងសុវត្ថិភាព - ធ្វើការជាមួយវិបផតថលគ្រប់គ្រងច្រកផ្លូវ SMB (បន្ថែមទៀតអំពី SMB gateways)
• IoT API - អន្តរកម្មជាមួយឧបករណ៍បញ្ជា IoT
• CloudGuard Connect API - ធ្វើការ​ជាមួយ CloudGuard ភ្ជាប់ (ដំណោះស្រាយសុវត្ថិភាព SD-WAN)
• Dome9 API - ធ្វើការ​ជាមួយ Dome9 ។

Python SDK បច្ចុប្បន្នគាំទ្រតែអន្តរកម្មជាមួយ API គ្រប់គ្រង និង Gaia API. យើងនឹងពិនិត្យមើលថ្នាក់សំខាន់ៗ វិធីសាស្រ្ត និងអថេរនៅក្នុងម៉ូឌុលនេះ។

ការដំឡើងម៉ូឌុល

ម៉ូឌុល cpapi ដំឡើងយ៉ាងរហ័ស និងងាយស្រួលពី ឃ្លាំង Check Point ផ្លូវការនៅលើ github ដោយមានជំនួយ PIP. សេចក្តីណែនាំអំពីការដំឡើងលម្អិតមាននៅក្នុង README.md. ម៉ូឌុលនេះត្រូវបានកែសម្រួលដើម្បីធ្វើការជាមួយ Python កំណែ 2.7 និង 3.7 ។ នៅក្នុងអត្ថបទនេះ ឧទាហរណ៍នឹងត្រូវបានផ្តល់ឱ្យដោយប្រើ Python 3.7 ។ ទោះយ៉ាងណាក៏ដោយ Python SDK អាចដំណើរការដោយផ្ទាល់ពី Check Point Management Server (Smart Management) ប៉ុន្តែពួកគេគាំទ្រតែ Python 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៖

អាគុយម៉ង់នៃវិធីសាស្ត្រ __init__ នៃថ្នាក់ APIClientArgs

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 គឺវិចារណញាណចំពោះអ្នកគ្រប់គ្រង Check Point ហើយមិនត្រូវការមតិយោបល់បន្ថែមទេ។

កំពុងភ្ជាប់តាមរយៈ APIClient និងកម្មវិធីគ្រប់គ្រងបរិបទ

Класс APIClient មធ្យោបាយងាយស្រួលបំផុតក្នុងការប្រើប្រាស់វាគឺតាមរយៈកម្មវិធីគ្រប់គ្រងបរិបទ។ អ្វីទាំងអស់ដែលត្រូវបញ្ជូនទៅកាន់ឧទាហរណ៍នៃថ្នាក់ APIClient គឺជាប៉ារ៉ាម៉ែត្រនៃការតភ្ជាប់ដែលត្រូវបានកំណត់ក្នុងជំហានមុន។

with APIClient(client_args) as client:

កម្មវិធីគ្រប់គ្រងបរិបទនឹងមិនធ្វើការហៅចូលដោយស្វ័យប្រវត្តិទៅកាន់ម៉ាស៊ីនមេ API នោះទេ ប៉ុន្តែវានឹងធ្វើការហៅចេញនៅពេលចេញពីវា។ ប្រសិនបើហេតុផលមួយចំនួនមិនតម្រូវឱ្យចាកចេញបន្ទាប់ពីបញ្ចប់ការធ្វើការជាមួយការហៅ API អ្នកត្រូវចាប់ផ្តើមធ្វើការដោយមិនប្រើកម្មវិធីគ្រប់គ្រងបរិបទ៖

client = APIClient(clieng_args)

កំពុងពិនិត្យមើលការតភ្ជាប់

មធ្យោបាយងាយស្រួលបំផុតដើម្បីពិនិត្យមើលថាតើការតភ្ជាប់ត្រូវនឹងប៉ារ៉ាម៉ែត្រដែលបានបញ្ជាក់កំពុងប្រើវិធីសាស្ត្រ ពិនិត្យ_ស្នាមម្រាមដៃ. ប្រសិនបើការផ្ទៀងផ្ទាត់ផលបូកនៃ sha1 hash សម្រាប់ស្នាមម្រាមដៃនៃវិញ្ញាបនបត្រ API ម៉ាស៊ីនមេបរាជ័យ (វិធីសាស្ត្រត្រឡប់ មិនពិត) បន្ទាប់មក វាជាធម្មតាបណ្តាលមកពីបញ្ហានៃការតភ្ជាប់ ហើយយើងអាចបញ្ឈប់ការប្រតិបត្តិនៃកម្មវិធី (ឬផ្តល់ឱ្យអ្នកប្រើប្រាស់នូវឱកាសដើម្បីកែតម្រូវទិន្នន័យការតភ្ជាប់):

    if client.check_fingerprint() is False:
        print("Could not get the server's fingerprint - Check connectivity with the server.")
        exit(1)

សូមចំណាំថានៅពេលអនាគតថ្នាក់ APIClient នឹងពិនិត្យមើលរាល់ការហៅ API (វិធីសាស្រ្ត api_call и api_queryយើងនឹងនិយាយអំពីពួកគេបន្តិចទៀត) វិញ្ញាបនបត្រស្នាមម្រាមដៃ sha1 នៅលើម៉ាស៊ីនមេ API ។ ប៉ុន្តែប្រសិនបើនៅពេលពិនិត្យស្នាមម្រាមដៃ sha1 នៃវិញ្ញាបនបត្រម៉ាស៊ីនមេ API កំហុសត្រូវបានរកឃើញ (វិញ្ញាបនបត្រមិនស្គាល់ ឬត្រូវបានផ្លាស់ប្តូរ) វិធីសាស្ត្រ ពិនិត្យ_ស្នាមម្រាមដៃ នឹងផ្តល់ឱកាសដើម្បីបន្ថែម/ផ្លាស់ប្តូរព័ត៌មានអំពីវានៅលើម៉ាស៊ីនមូលដ្ឋានដោយស្វ័យប្រវត្តិ។ ការត្រួតពិនិត្យនេះអាចត្រូវបានបិទទាំងស្រុង (ប៉ុន្តែនេះអាចណែនាំបានលុះត្រាតែស្គ្រីបដំណើរការនៅលើម៉ាស៊ីនមេ API ខ្លួនវា នៅពេលភ្ជាប់ទៅ 127.0.0.1) ដោយប្រើអាគុយម៉ង់ APIClientArgs - unsafe_auto_accept (សូមមើលបន្ថែមអំពី APIClientArgs មុននៅក្នុង "ការកំណត់ប៉ារ៉ាម៉ែត្រការតភ្ជាប់") ។

client_args = APIClientArgs(unsafe_auto_accept=True)

ចូលទៅម៉ាស៊ីនមេ API

У APIClient មានវិធីសាស្រ្តជាច្រើនដូចជា 3 សម្រាប់ចូលទៅក្នុងម៉ាស៊ីនមេ API ហើយពួកគេម្នាក់ៗយល់ពីអត្ថន័យ sid(session-id) ដែលត្រូវបានប្រើដោយស្វ័យប្រវត្តិនៅក្នុងការហៅ API ជាបន្តបន្ទាប់នីមួយៗនៅក្នុងបឋមកថា (ឈ្មោះនៅក្នុងបឋមកថានៃប៉ារ៉ាម៉ែត្រនេះគឺ X-chkp-sid) ដូច្នេះមិនចាំបាច់ដំណើរការប៉ារ៉ាម៉ែត្រនេះទៀតទេ។

វិធីសាស្រ្តចូល

ជម្រើសដោយប្រើការចូល និងពាក្យសម្ងាត់ (ក្នុងឧទាហរណ៍ ឈ្មោះអ្នកប្រើប្រាស់ អ្នកគ្រប់គ្រង និងពាក្យសម្ងាត់ 1q2w3e ត្រូវបានឆ្លងកាត់ជាអាគុយម៉ង់ទីតាំង)៖

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

ប៉ារ៉ាម៉ែត្រជម្រើសបន្ថែមក៏មាននៅក្នុងវិធីសាស្ត្រចូលដែរ នេះគឺជាឈ្មោះ និងតម្លៃលំនាំដើមរបស់ពួកគេ៖

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

វិធីសាស្ត្រ Login_with_api_key

ជម្រើសដោយប្រើសោ api (គាំទ្រដោយចាប់ផ្តើមពីកំណែគ្រប់គ្រង R80.40/Management 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_call и api_query. ចូរយើងស្វែងយល់ថាតើអ្វីជាភាពខុសគ្នារវាងពួកគេ។

api_call

វិធីសាស្រ្តនេះអាចអនុវត្តបានសម្រាប់ការហៅទូរសព្ទណាមួយ។ យើងត្រូវឆ្លងកាត់ផ្នែកចុងក្រោយសម្រាប់ការហៅ api និង payload នៅក្នុងផ្នែកសំណើប្រសិនបើចាំបាច់។ ប្រសិនបើ payload គឺទទេ នោះវាមិនអាចបញ្ជូនបានទាល់តែសោះ៖

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 ដែលដំណើរការនេះដោយស្វ័យប្រវត្តិ។ ឧទាហរណ៍​នៃ​ការ​ហៅ​ទូរសព្ទ​ដែល​ត្រូវ​ការ​វិធីសាស្ត្រ​នេះ៖ show-sessions, show-hosts, show-networks, show-wildcards, show-group, show-address-ranges, show-simple-gateways, show-simple-cluster, show-access-roles, show-trusted-client, កញ្ចប់បង្ហាញ. តាមការពិត យើងឃើញពាក្យពហុវចនៈនៅក្នុងឈ្មោះនៃការហៅ 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

បន្ទាប់ពីនេះអ្នកអាចប្រើអថេរ និងវិធីសាស្រ្តនៃថ្នាក់ APIResponse(ទាំងខាងក្នុងអ្នកគ្រប់គ្រងបរិបទ និងខាងក្រៅ)។ នៅថ្នាក់ APIResponse វិធីសាស្រ្ត 4 និង 5 variables ត្រូវបានកំណត់ជាមុន យើងនឹងរស់នៅលើអ្វីដែលសំខាន់បំផុតដោយលម្អិតបន្ថែមទៀត។

ភាពជោគជ័យ

ដើម្បីចាប់ផ្តើម វាជាគំនិតល្អក្នុងការធ្វើឱ្យប្រាកដថាការហៅ API ទទួលបានជោគជ័យ និងផ្តល់លទ្ធផលមកវិញ។ មានវិធីសាស្រ្តសម្រាប់រឿងនេះ ភាពជោគជ័យ:

In [49]: api_versions.success                                                   
Out[49]: True

ត្រឡប់ True ប្រសិនបើការហៅ API ជោគជ័យ (លេខកូដឆ្លើយតប - 200) និង False ប្រសិនបើមិនជោគជ័យ (លេខកូដឆ្លើយតបផ្សេងទៀត)។ វាងាយស្រួលប្រើភ្លាមៗបន្ទាប់ពីការហៅ 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

ក្នុងករណីនេះ វាអាចចាំបាច់ក្នុងការផ្លាស់ប្តូរតម្លៃនៃស្ថានភាពជោគជ័យ។ តាមបច្ចេកទេស អ្នកអាចដាក់អ្វីក៏បាន សូម្បីតែខ្សែធម្មតាក៏ដោយ។ ប៉ុន្តែឧទាហរណ៍ជាក់ស្តែងនឹងត្រូវបានកំណត់ឡើងវិញនូវប៉ារ៉ាម៉ែត្រនេះទៅជា False ក្រោមលក្ខខណ្ឌមួយចំនួនដែលភ្ជាប់មកជាមួយ។ ខាងក្រោមនេះ សូមយកចិត្តទុកដាក់លើឧទាហរណ៍ នៅពេលដែលមានកិច្ចការដែលកំពុងដំណើរការនៅលើម៉ាស៊ីនមេគ្រប់គ្រង ប៉ុន្តែយើងនឹងពិចារណាសំណើនេះមិនជោគជ័យ (យើងនឹងកំណត់អថេរជោគជ័យទៅជា មិនពិតទោះបីជាការពិតដែលថាការហៅ 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']}

error_message

ព័ត៌មាននេះអាចប្រើបានតែនៅពេលដែលមានកំហុសកើតឡើងខណៈពេលដំណើរការសំណើ API (លេខកូដឆ្លើយតប មិនមាន ២០០)។ លទ្ធផលឧទាហរណ៍

In [107]: api_versions.error_message                                            
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'

ឧទាហរណ៍មានប្រយោជន៍

ខាងក្រោមនេះគឺជាឧទាហរណ៍ដែលប្រើការហៅ API ដែលត្រូវបានបន្ថែមនៅក្នុង Management API 1.6។

ជាដំបូង សូមក្រឡេកមើលពីរបៀបដែលការហៅទូរស័ព្ទដំណើរការ កម្មវិធីបន្ថែម и ជួរបន្ថែមអាសយដ្ឋាន. ឧបមាថាយើងត្រូវបង្កើតអាសយដ្ឋាន IP ទាំងអស់នៃបណ្តាញរង 192.168.0.0/24 ដែលជា octet ចុងក្រោយគឺ 5 ជាវត្ថុនៃប្រភេទម៉ាស៊ីន ហើយសរសេរអាសយដ្ឋាន IP ផ្សេងទៀតទាំងអស់ជាវត្ថុនៃប្រភេទជួរអាសយដ្ឋាន។ ក្នុងករណីនេះ ដកអាសយដ្ឋានបណ្តាញរង និងអាសយដ្ឋានផ្សាយ។

ដូច្នេះ ខាងក្រោមនេះគឺជាស្គ្រីបដែលដោះស្រាយបញ្ហានេះ ហើយបង្កើតវត្ថុ 50 នៃប្រភេទម៉ាស៊ីន និង 51 វត្ថុនៃប្រភេទជួរអាសយដ្ឋាន។ ដើម្បីដោះស្រាយបញ្ហា ការហៅ API 101 ត្រូវបានទាមទារ (មិនរាប់បញ្ចូលការហៅចេញចុងក្រោយ)។ ផងដែរ ដោយប្រើម៉ូឌុល timeit យើងគណនាពេលវេលាដែលវាត្រូវការដើម្បីប្រតិបត្តិស្គ្រីបរហូតដល់ការផ្លាស់ប្តូរត្រូវបានបោះពុម្ពផ្សាយ។

ស្គ្រីបដោយប្រើ add-host និង add-address-range

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 មួយដោយប្រើ លុប-វត្ថុ-បាច់. ឥឡូវនេះសូមមើលឧទាហរណ៍កូដដែលលុបម៉ាស៊ីនទាំងអស់ដែលបានបង្កើតពីមុនតាមរយៈ 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)

មុខងារទាំងអស់ដែលបង្ហាញនៅក្នុងការចេញផ្សាយថ្មីនៃកម្មវិធី Check Point ទទួលបានការហៅ API ភ្លាមៗ។ ដូច្នេះនៅក្នុង R80.40 "លក្ខណៈពិសេស" ដូចជាការត្រលប់ទៅការពិនិត្យឡើងវិញ និង Smart Task បានបង្ហាញខ្លួន ហើយការហៅ API ដែលត្រូវគ្នាត្រូវបានរៀបចំភ្លាមៗសម្រាប់ពួកគេ។ លើសពីនេះ មុខងារទាំងអស់នៅពេលផ្លាស់ប្តូរពីកុងសូល Legacy ទៅមុខងារគោលការណ៍បង្រួបបង្រួម ក៏ទទួលបានការគាំទ្រ 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")

កំពុងដំណើរការស្គ្រីប Python នៅលើម៉ាស៊ីនមេគ្រប់គ្រងចំណុចត្រួតពិនិត្យ

អ្វីគ្រប់យ៉ាងគឺដូចគ្នា។ README.md មានព័ត៌មានអំពីរបៀបដំណើរការស្គ្រីប Python ដោយផ្ទាល់ពីម៉ាស៊ីនមេបញ្ជា។ វាអាចមានភាពងាយស្រួលនៅពេលដែលអ្នកមិនអាចភ្ជាប់ទៅម៉ាស៊ីនមេ API ពីម៉ាស៊ីនផ្សេងទៀត។ ខ្ញុំបានថតវីដេអូរយៈពេលប្រាំមួយនាទី ដែលខ្ញុំមើលទៅក្នុងការដំឡើងម៉ូឌុល cpapi និងលក្ខណៈពិសេសនៃដំណើរការស្គ្រីប Python នៅលើម៉ាស៊ីនមេបញ្ជា។ ជាឧទាហរណ៍ ស្គ្រីបមួយត្រូវបានដំណើរការដែលធ្វើស្វ័យប្រវត្តិកម្មការកំណត់រចនាសម្ព័ន្ធច្រកផ្លូវថ្មីសម្រាប់កិច្ចការដូចជា សវនកម្មបណ្តាញ។ ការត្រួតពិនិត្យសុវត្ថិភាព. ក្នុងចំណោមលក្ខណៈពិសេសដែលខ្ញុំត្រូវដោះស្រាយ៖ មុខងារមិនទាន់បានបង្ហាញខ្លួននៅក្នុង Python 2.7 នៅឡើយទេ ការបញ្ចូលដូច្នេះ ដើម្បីដំណើរការព័ត៌មានដែលអ្នកប្រើប្រាស់បញ្ចូល មុខងារមួយត្រូវបានប្រើប្រាស់ raw_បញ្ចូល. បើមិនដូច្នេះទេ កូដគឺដូចគ្នានឹងការបើកដំណើរការពីម៉ាស៊ីនផ្សេងទៀតដែរ គ្រាន់តែវាងាយស្រួលប្រើមុខងារជាង 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","пароль","Пароль","Ключ","ключ","шифр","Шифр"] }

សេចក្តីសន្និដ្ឋាន

អត្ថបទនេះពិនិត្យតែលទ្ធភាពជាមូលដ្ឋាននៃការងារប៉ុណ្ណោះ។ ពស់ថ្លាន់ SDK និងម៉ូឌុល cpapi(ដូចដែលអ្នកប្រហែលជាបានទាយ ទាំងនេះពិតជាមានន័យដូចគ្នា) ហើយដោយសិក្សាកូដនៅក្នុងម៉ូឌុលនេះ អ្នកនឹងរកឃើញលទ្ធភាពកាន់តែច្រើនក្នុងការធ្វើការជាមួយវា។ វាអាចទៅរួចដែលអ្នកចង់បន្ថែមវាជាមួយនឹងថ្នាក់ មុខងារ វិធីសាស្រ្ត និងអថេរផ្ទាល់ខ្លួនរបស់អ្នក។ អ្នកតែងតែអាចចែករំលែកការងាររបស់អ្នក និងមើលស្គ្រីបផ្សេងទៀតសម្រាប់ Check Point នៅក្នុងផ្នែក CodeHub នៅក្នុងសហគមន៍ CheckMatesដែលប្រមូលផ្តុំទាំងអ្នកអភិវឌ្ឍន៍ផលិតផល និងអ្នកប្រើប្រាស់។

រីករាយក្នុងការសរសេរកូដ និងអរគុណសម្រាប់ការអានដល់ចប់!

ប្រភព: www.habr.com