API ප්රතිචාර විශ්ලේෂණය සඳහා API ඉල්ලීම් සහ මෙවලම් ගතිකව උත්පාදනය කිරීමට හැකි වූ විට, වැඩසටහන් කේතය සමඟ භාවිතා කරන විට API සමඟ අන්තර්ක්‍රියා කිරීමේ සම්පූර්ණ බලය අනාවරණය වේ. කෙසේ වෙතත්, එය තවමත් නොපෙනී පවතී පයිතන් මෘදුකාංග සංවර්ධන කට්ටලය (මෙතැන් සිට Python SDK ලෙස හැඳින්වේ) සඳහා Point Management API පරීක්ෂා කරන්න, නමුත් නිෂ්ඵලයි. එය සංවර්ධකයින්ගේ සහ ස්වයංක්‍රීය ලෝලීන්ගේ ජීවිතය සැලකිය යුතු ලෙස සරල කරයි. Python මෑතකදී විශාල ජනප්‍රියත්වයක් ලබා ඇති අතර මම එම අඩුව පුරවා ප්‍රධාන විශේෂාංග සමාලෝචනය කිරීමට තීරණය කළෙමි. . මෙම ලිපිය Habré පිළිබඳ තවත් ලිපියකට විශිෂ්ට එකතු කිරීමක් ලෙස සේවය කරයි . අපි Python SDK භාවිතයෙන් ස්ක්රිප්ට් ලියන ආකාරය දෙස බලමු සහ 1.6 අනුවාදයේ (R80.40 සිට සහය දක්වන) නව කළමනාකරණ API ක්‍රියාකාරීත්වය දෙස සමීපව බලමු. ලිපිය තේරුම් ගැනීමට, ඔබට APIs සහ Python සමඟ වැඩ කිරීමේ මූලික දැනුම අවශ්ය වේ.
චෙක් පොයින්ට් API සක්‍රියව සංවර්ධනය කරමින් සිටින අතර මේ මොහොතේ පහත ඒවා නිකුත් කර ඇත:
- - API හරහා පාලන සේවාදායකය සමඟ වැඩ කරන්න (සහ පාලන සේවාදායකය මගින් පාලනය වන ද්වාරවල ස්ක්රිප්ට් ක්‍රියාත්මක කිරීමේ හැකියාව)
- - ආරක්ෂක දොරටු සමඟ වැඩ කරන්න
- — Check Point cloud හි වැලිපිල්ලක් සමඟ වැඩ කිරීම
- - ද්වාර මත අනන්‍යතා දැනුවත් කිරීමේ තලය සමඟ වැඩ කිරීම
- - SMB ද්වාර කළමනාකරණ ද්වාරය සමඟ වැඩ කරන්න ()
- - IoT පාලකයන් සමඟ අන්තර්ක්‍රියා
- - සමඟ වැඩ කරන්න (SD-WAN ආරක්ෂක විසඳුම)
- - සමඟ වැඩ කරන්න
Python SDK දැනට සහාය දක්වන්නේ කළමනාකරණ API සහ සමඟ අන්තර්ක්‍රියා සඳහා පමණි Gaia API. අපි මෙම මොඩියුලයේ වඩාත්ම වැදගත් පන්ති, ක්රම සහ විචල්යයන් දෙස බලමු.
මොඩියුලය ස්ථාපනය කිරීම
මොඩියුලය cpapi සිට ඉක්මනින් සහ පහසුවෙන් ස්ථාපනය කරයි උදව්වෙන් එක පිප්ස් එකකට. සවිස්තරාත්මක ස්ථාපන උපදෙස් ලබා ගත හැකිය . මෙම මොඩියුලය Python අනුවාද 2.7 සහ 3.7 සමඟ වැඩ කිරීමට අනුවර්තනය කර ඇත. මෙම ලිපියෙන්, Python 3.7 භාවිතයෙන් උදාහරණ ලබා දෙනු ඇත. කෙසේ වෙතත්, Python 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 = contextAPIClientArgs පන්තියේ අවස්ථා වලදී භාවිතා කළ හැකි තර්ක චෙක් පොයින්ට් පරිපාලකයින්ට අවබෝධ වන අතර අමතර අදහස් අවශ්ය නොවන බව මම විශ්වාස කරමි.
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 ක් පමණ ඇති අතර, ඒ සෑම එකක්ම එහි තේරුම තේරුම් ගනී Sid(session-id), එය ශීර්ෂයේ ඇති සෑම ඊළඟ API ඇමතුමකදීම ස්වයංක්‍රීයව භාවිතා වේ (මෙම පරාමිතියේ ශීර්ෂයේ නම වේ X-chkp-sid), එබැවින් මෙම පරාමිතිය තවදුරටත් සැකසීමට අවශ්ය නොවේ.
පිවිසුම් ක්රමය
පිවිසුම් සහ මුරපදය භාවිතා කිරීමේ විකල්පය (උදාහරණයේදී, පරිපාලක පරිශීලක නාමය සහ මුරපදය 1q2w3e ස්ථානීය තර්ක ලෙස සම්මත කර ඇත):
login = client.login('admin', '1q2w3e') පිවිසුම් ක්රමය තුළ අමතර විකල්ප පරාමිතීන් ද ඇත; මෙහි ඒවායේ නම් සහ පෙරනිමි අගයන් වේ:
continue_last_session=False, domain=None, read_only=False, payload=Noneලොගින්_with_api_key ක්රමය
api යතුරක් භාවිතා කිරීමේ විකල්පය (කළමනාකරණ අනුවාදය R80.40/Management API v1.6 සිට සහය දක්වයි, "3TsbPJ8ZKjaJGvFyoFqHFA==" API යතුරු අවසර ක්රමය සමඟ කළමනාකරණ සේවාදායකයේ එක් පරිශීලකයෙකු සඳහා වන API ප්‍රධාන අගය මෙයයි:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') ක්රමය තුළ api_key_සමග_පුරන්න ක්‍රමයේ ඇති විකල්ප පරාමිතීන්ම ඇත ඇතුල් වන්න.
login_as_root ක්රමය
API සේවාදායකයක් සහිත දේශීය යන්ත්‍රයකට පුරනය වීමේ විකල්පය:
login = client.login_as_root()මෙම ක්රමය සඳහා ඇත්තේ විකල්ප පරාමිති දෙකක් පමණි:
domain=None, payload=Noneඅවසාන වශයෙන් API තමන්ව හඳුන්වනවා
ක්රම හරහා API ඇමතුම් ලබා ගැනීමට අපට විකල්ප දෙකක් තිබේ api_call и api_query. ඔවුන් අතර ඇති වෙනස කුමක්දැයි සොයා බලමු.
api_call
මෙම ක්රමය ඕනෑම ඇමතුම් සඳහා අදාළ වේ. අවශ්ය නම් අපි api ඇමතුම සහ ඉල්ලීම් බොඩියේ ගෙවීම සඳහා අවසාන කොටස සමත් කළ යුතුය. ගෙවීම හිස් නම්, එය කිසිසේත් මාරු කළ නොහැක:
api_versions = client.api_call('show-api-versions') කප්පාදුවට පහළින් මෙම ඉල්ලීම සඳහා ප්රතිදානය:
In [23]: api_versions
Out[23]:
APIResponse({
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"res_obj": {
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"status_code": 200
},
"status_code": 200,
"success": true
})
show_host = client.api_call('show-host', {'name' : 'h_8.8.8.8'})කප්පාදුවට පහළින් මෙම ඉල්ලීම සඳහා ප්රතිදානය:
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"res_obj": {
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"status_code": 200
},
"status_code": 200,
"success": true
})
api_query
මෙම ක්රමය අදාළ වන්නේ ඕෆ්සෙට් ප්රතිදානය ඇතුළත් ඇමතුම් සඳහා පමණක් බව වහාම වෙන්කරවා ගැනීමට මට ඉඩ දෙන්න. එවැනි නිගමනයක් සිදු වන්නේ එහි විශාල තොරතුරු ප්‍රමාණයක් අඩංගු වන විට හෝ අඩංගු විය හැකි විටය. උදාහරණයක් ලෙස, මෙය කළමනාකරණ සේවාදායකයේ ඇති සියලුම ධාරක වස්තු ලැයිස්තුවක් සඳහා ඉල්ලීමක් විය හැකිය. එවැනි ඉල්ලීම් සඳහා, API පෙරනිමියෙන් වස්තු 50 ක ලැයිස්තුවක් ලබා දෙයි (ප්‍රතිචාරයේ දී ඔබට සීමාව වස්තු 500 දක්වා වැඩි කළ හැක). තවද තොරතුරු කිහිප වතාවක් ඇද නොගැනීම සඳහා, API ඉල්ලීමෙහි ඕෆ්සෙට් පරාමිතිය වෙනස් කිරීම, මෙය ස්වයංක්‍රීයව ක්‍රියා කරන api_query ක්රමයක් ඇත. මෙම ක්රමය අවශ්ය වන ඇමතුම් සඳහා උදාහරණ: සංදර්ශන-සැසි, සංදර්ශන-ධාරක, සංදර්ශන-ජාල, සංදර්ශන-වයිල්ඩ්කාඩ්, ප්‍රදර්ශන-කණ්ඩායම්, සංදර්ශන-ලිපින-පරාස, සංදර්ශන-සරල-දොරටු, සංදර්ශන-සරල-පොකුරු, සංදර්ශන-ප්‍රවේශ-භූමකාමී, සංදර්ශන-විශ්වාසදායක-සේවාදායකයින් සංදර්ශන පැකේජ. ඇත්ත වශයෙන්ම, අපි මෙම API ඇමතුම්වල නාමයෙන් බහු වචන දකිමු, එබැවින් මෙම ඇමතුම් හැසිරවීමට පහසු වනු ඇත. api_query
show_hosts = client.api_query('show-hosts') කප්පාදුවට පහළින් මෙම ඉල්ලීම සඳහා ප්රතිදානය:
In [21]: show_hosts
Out[21]:
APIResponse({
"data": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"res_obj": {
"data": {
"from": 1,
"objects": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"to": 2,
"total": 2
},
"status_code": 200
},
"status_code": 200,
"success": true
})
API ඇමතුම්වල ප්‍රතිඵල සැකසීම
මෙයින් පසු ඔබට පන්තියේ විචල්යයන් සහ ක්රම භාවිතා කළ හැකිය APIR ප්‍රතිචාරය(සන්දර්භය කළමනාකරු ඇතුළත සහ පිටත). පන්තියේදී APIR ප්‍රතිචාරය ක්රම 4 ක් සහ විචල්‍ය 5 ක් පූර්ව නිර්වචනය කර ඇත; අපි වඩාත් වැදගත් ඒවා වඩාත් විස්තරාත්මකව වාසය කරමු.
සාර්ථකත්වය
ආරම්භ කිරීම සඳහා, API ඇමතුම සාර්ථක වී ප්‍රතිඵලයක් ලබා දුන් බව සහතික කර ගැනීම හොඳ අදහසකි. මේ සඳහා ක්රමයක් තිබේ සාර්ථකත්වය:
In [49]: api_versions.success
Out[49]: True
API ඇමතුම සාර්ථක නම් සත්‍ය (ප්රතිචාර කේතය - 200) සහ සාර්ථක නොවන්නේ නම් අසත්‍ය (වෙනත් ප්රතිචාර කේතයක්) ලබා දෙයි. ප්රතිචාර කේතය මත පදනම්ව විවිධ තොරතුරු පෙන්වීමට API ඇමතුමකින් පසු වහාම භාවිතා කිරීම පහසුය.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) තත්ව කේතය
API ඇමතුමක් ලබා දීමෙන් පසු ප්රතිචාර කේතය ලබා දෙයි.
In [62]: api_versions.status_code
Out[62]: 400
හැකි ප්රතිචාර කේත: 200,400,401,403,404,409,500,501.
සකසන්න_සාර්ථක_තත්ත්වය
මෙම අවස්ථාවෙහිදී, සාර්ථක තත්ත්වයේ අගය වෙනස් කිරීම අවශ්ය විය හැකිය. තාක්ෂණික වශයෙන්, ඔබට එහි ඕනෑම දෙයක් තැබිය හැකිය, සාමාන්‍ය නූල් පවා. නමුත් සැබෑ උදාහරණයක් වනුයේ යම් යම් කොන්දේසි යටතේ මෙම පරාමිතිය 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']}
දෝෂ_පණිවිඩය
මෙම තොරතුරු ලබා ගත හැක්කේ API ඉල්ලීම සැකසීමේදී දෝෂයක් සිදු වූ විට පමණි (ප්රතිචාර කේතය නෑ 200). උදාහරණ ප්රතිදානය
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
ප්රයෝජනවත් උදාහරණ
කළමනාකරණ API 1.6 හි එක් කරන ලද API ඇමතුම් භාවිතා කරන උදාහරණ පහත දැක්වේ.
පළමුව, ඇමතුම් ක්‍රියා කරන ආකාරය බලමු add-host и add-address-range. අපි හිතමු අපි 192.168.0.0/24 උපජාලයේ සියලුම IP ලිපින නිර්මාණය කළ යුතු අතර, එහි අවසාන අෂ්ටකය වන 5, ධාරක ආකාරයේ වස්තූන් ලෙස, සහ අනෙකුත් සියලුම IP ලිපින ලිපින පරාසයේ වස්තු ලෙස ලිවිය යුතුය. මෙම අවස්ථාවේදී, උපජාල ලිපිනය සහ විකාශන ලිපිනය බැහැර කරන්න.
ඉතින්, පහත දැක්වෙන්නේ මෙම ගැටළුව විසඳන සහ ධාරක වර්ගයේ වස්තු 50 ක් සහ ලිපින පරාසයේ වස්තු 51 ක් නිර්මාණය කරන ස්ක්රිප්ට් එකකි. ගැටළුව විසඳීම සඳහා, API ඇමතුම් 101ක් අවශ්ය වේ (අවසන් ප්‍රකාශන ඇමතුම ගණන් නොගනී). එසේම, timeit මොඩියුලය භාවිතා කරමින්, වෙනස්කම් ප්‍රකාශයට පත් කරන තෙක් ස්ක්රිප්ට් ක්‍රියාත්මක කිරීමට ගතවන කාලය අපි ගණනය කරමු.
එකතු කිරීමේ සත්කාරක සහ එකතු කිරීමේ ලිපින පරාසය භාවිතා කරමින් ස්ක්රිප්ට්
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 දක්වා ගත වේ, කළමනාකරණ සේවාදායකයේ බර අනුව. එනම්, සාමාන්‍යයෙන්, API වස්තු 101 ක් මත, කණ්ඩායම් ආකාරයේ ඇමතුමක් 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.
delete-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 හි, Revert to revision සහ Smart Task වැනි "විශේෂාංග" දර්ශනය වූ අතර, ඒවාට අනුරූප API ඇමතුම් වහාම සකස් කරන ලදී. එපමනක් නොව, Legacy console සිට Unified Policy මාදිලිය වෙත ගමන් කරන විට සියලුම ක්‍රියාකාරීත්වයන් API සහාය ද ලබා ගනී. උදාහරණයක් ලෙස, මෘදුකාංග අනුවාදය R80.40 හි දිගුකාලීනව බලා සිටි යාවත්කාලීනය වූයේ HTTPS පරීක්ෂණ ප්‍රතිපත්තිය උරුම ප්‍රකාරයේ සිට ඒකාබද්ධ ප්‍රතිපත්ති ප්‍රකාරයට ගෙන යාමයි, සහ මෙම ක්‍රියාකාරීත්වයට වහාම API ඇමතුම් ලැබුණි. රටවල් ගණනාවක නීතියට අනුකූලව පරීක්ෂා කිරීම තහනම් කර ඇති (සෞඛ්‍ය, මූල්‍ය, රාජ්‍ය සේවා) පරීක්‍ෂාවෙන් කාණ්ඩ 3ක් බැහැර කරන HTTPS පරීක්ෂණ ප්‍රතිපත්තියේ ඉහළම ස්ථානයට රීතියක් එක් කරන කේතයක උදාහරණයක් මෙන්න.
HTTPS පරීක්ෂණ ප්‍රතිපත්තියට රීතියක් එක් කරන්න
from cpapi import APIClient, APIClientArgs
client_args = APIClientArgs(server="192.168.47.240")
data = {
"layer" : "Default Layer",
"position" : "top",
"name" : "Legal Requirements",
"action": "bypass",
"site-category": ["Health", "Government / Military", "Financial Services"]
}
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
add_https_rule = client.api_call("add-https-rule", data)
publish = client.api_call("publish")
චෙක් පොයින්ට් කළමනාකරණ සේවාදායකයේ පයිතන් ස්ක්රිප්ට් ධාවනය කිරීම
හැම දෙයක්ම එකයි පාලක සේවාදායකයෙන් කෙලින්ම පයිතන් ස්ක්රිප්ට් ධාවනය කරන්නේ කෙසේද යන්න පිළිබඳ තොරතුරු අඩංගු වේ. ඔබට වෙනත් යන්ත්‍රයකින් API සේවාදායකයට සම්බන්ධ වීමට නොහැකි වූ විට මෙය පහසු විය හැක. මම මොඩියුලය ස්ථාපනය කිරීම දෙස බලන මිනිත්තු හයක වීඩියෝවක් පටිගත කළෙමි cpapi සහ පාලන සේවාදායකයේ පයිතන් ස්ක්රිප්ට් ධාවනය කිරීමේ විශේෂාංග. උදාහරණයක් ලෙස, ජාල විගණනය වැනි කාර්යයක් සඳහා නව ද්වාරයක වින්‍යාසය ස්වයංක්‍රීය කරන ස්ක්රිප්ට් එකක් ක්‍රියාත්මක වේ. ආරක්ෂක පරීක්ෂාව. මට ගනුදෙනු කිරීමට සිදු වූ විශේෂාංග අතර: ශ්‍රිතය තවමත් පයිතන් 2.7 හි දර්ශනය වී නොමැත ආදානය, එබැවින් පරිශීලකයා ඇතුල් කරන තොරතුරු සැකසීමට, ශ්රිතයක් භාවිතා වේ අමු_ආදානය. එසේ නොමැති නම්, කේතය වෙනත් යන්ත්‍ර වලින් දියත් කිරීම සඳහා සමාන වේ, එය කාර්යය භාවිතා කිරීම වඩාත් පහසු වේ ලොගින්_මුල ලෙස, කළමනාකරණ සේවාදායකයේ ඔබගේම පරිශීලක නාමය, මුරපදය සහ IP ලිපිනය නැවත සඳහන් නොකිරීමට.
ආරක්ෂක පරීක්ෂාව ඉක්මන් පිහිටුවීම සඳහා ස්ක්රිප්ට්
from __future__ import print_function
import getpass
import sys, os
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
from cpapi import APIClient, APIClientArgs
def main():
with APIClient() as client:
# if client.check_fingerprint() is False:
# print("Could not get the server's fingerprint - Check connectivity with the server.")
# exit(1)
login_res = client.login_as_root()
if login_res.success is False:
print("Login failed:n{}".format(login_res.error_message))
exit(1)
gw_name = raw_input("Enter the gateway name:")
gw_ip = raw_input("Enter the gateway IP address:")
if sys.stdin.isatty():
sic = getpass.getpass("Enter one-time password for the gateway(SIC): ")
else:
print("Attention! Your password will be shown on the screen!")
sic = raw_input("Enter one-time password for the gateway(SIC): ")
version = raw_input("Enter the gateway version(like RXX.YY):")
add_gw = client.api_call("add-simple-gateway", {'name' : gw_name, 'ipv4-address' : gw_ip, 'one-time-password' : sic, 'version': version.capitalize(), 'application-control' : 'true', 'url-filtering' : 'true', 'ips' : 'true', 'anti-bot' : 'true', 'anti-virus' : 'true', 'threat-emulation' : 'true'})
if add_gw.success and add_gw.data['sic-state'] != "communicating":
print("Secure connection with the gateway hasn't established!")
exit(1)
elif add_gw.success:
print("The gateway was added successfully.")
gw_uid = add_gw.data['uid']
gw_name = add_gw.data['name']
else:
print("Failed to add the gateway - {}".format(add_gw.error_message))
exit(1)
change_policy = client.api_call("set-access-layer", {"name" : "Network", "applications-and-url-filtering": "true", "content-awareness": "true"})
if change_policy.success:
print("The policy has been changed successfully")
else:
print("Failed to change the policy- {}".format(change_policy.error_message))
change_rule = client.api_call("set-access-rule", {"name" : "Cleanup rule", "layer" : "Network", "action": "Accept", "track": {"type": "Detailed Log", "accounting": "true"}})
if change_rule.success:
print("The cleanup rule has been changed successfully")
else:
print("Failed to change the cleanup rule- {}".format(change_rule.error_message))
# publish the result
publish_res = client.api_call("publish", {})
if publish_res.success:
print("The changes were published successfully.")
else:
print("Failed to publish the changes - {}".format(install_tp_policy.error_message))
install_access_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'true', "threat-prevention" : 'false', "targets" : gw_uid})
if install_access_policy.success:
print("The access policy has been installed")
else:
print("Failed to install access policy - {}".format(install_tp_policy.error_message))
install_tp_policy = client.api_call("install-policy", {"policy-package" : "Standard", "access" : 'false', "threat-prevention" : 'true', "targets" : gw_uid})
if install_tp_policy.success:
print("The threat prevention policy has been installed")
else:
print("Failed to install threat prevention policy - {}".format(install_tp_policy.error_message))
# add passwords and passphrases to dictionary
with open('additional_pass.conf') as f:
line_num = 0
for line in f:
line_num += 1
add_password_dictionary = client.api_call("run-script", {"script-name" : "Add passwords and passphrases", "script" : "printf "{}" >> $FWDIR/conf/additional_pass.conf".format(line), "targets" : gw_name})
if add_password_dictionary.success:
print("The password dictionary line {} was added successfully".format(line_num))
else:
print("Failed to add the dictionary - {}".format(add_password_dictionary.error_message))
main() මුරපද ශබ්දකෝෂයක් සහිත උදාහරණ ගොනුවක් අතිරේක_pass.conf
{
"passwords" : ["malware","malicious","infected","Infected"],
"phrases" : ["password","Password","Pass","pass","codigo","key","pwd","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
නිගමනය
මෙම ලිපිය වැඩ කිරීමේ මූලික හැකියාවන් පමණක් පරීක්ෂා කරයි පයිතන් එස්ඩීකේ සහ මොඩියුලය cpapi(ඔබ අනුමාන කළ පරිදි, මේවා ඇත්ත වශයෙන්ම සමාන පද වේ), මෙම මොඩියුලයේ කේතය අධ්‍යයනය කිරීමෙන් ඔබට එය සමඟ වැඩ කිරීමේදී ඊටත් වඩා හැකියාවන් සොයාගත හැකිය. ඔබට එය ඔබේම පන්ති, ශ්‍රිත, ක්රම සහ විචල්‍ය සමඟ අතිරේක කිරීමට අවශ්ය වනු ඇත. ඔබට සෑම විටම ඔබේ වැඩ බෙදා ගැනීමට සහ කොටසේ චෙක් පොයින්ට් සඳහා වෙනත් ස්ක්රිප්ට් බැලීමට හැකිය ප්රජාව තුළ , එය නිෂ්පාදන සංවර්ධකයින් සහ පරිශීලකයින් යන දෙකම එකට ගෙන එයි.
ප්‍රීතිමත් කේතීකරණය සහ අවසානය දක්වා කියවීමට ස්තූතියි!
මූලාශ්රය: www.habr.com