API ప్రతిస్పందనలను విశ్లేషించడానికి API అభ్యర్థనలు మరియు సాధనాలను డైనమిక్గా రూపొందించడం సాధ్యమైనప్పుడు, ప్రోగ్రామ్ కోడ్తో కలిసి ఉపయోగించినప్పుడు APIలతో పరస్పర చర్య యొక్క పూర్తి శక్తి బహిర్గతమవుతుంది. అయినప్పటికీ, ఇది ఇప్పటికీ గుర్తించబడదు పైథాన్ సాఫ్ట్వేర్ డెవలప్మెంట్ కిట్ (ఇకపై పైథాన్ SDKగా సూచిస్తారు) కోసం పాయింట్ మేనేజ్మెంట్ APIని తనిఖీ చేయండి, కానీ ఫలించలేదు. ఇది డెవలపర్లు మరియు ఆటోమేషన్ ఔత్సాహికుల జీవితాన్ని గణనీయంగా సులభతరం చేస్తుంది. పైథాన్ ఇటీవల అపారమైన ప్రజాదరణ పొందింది మరియు నేను ఖాళీని పూరించడానికి మరియు ప్రధాన లక్షణాలను సమీక్షించాలని నిర్ణయించుకున్నాను. . ఈ వ్యాసం హబ్రేపై మరొక కథనానికి అద్భుతమైన అదనంగా ఉపయోగపడుతుంది . మేము పైథాన్ SDKని ఉపయోగించి స్క్రిప్ట్లను ఎలా వ్రాయాలో పరిశీలిస్తాము మరియు వెర్షన్ 1.6 (R80.40 నుండి మద్దతు)లోని కొత్త మేనేజ్మెంట్ API ఫంక్షనాలిటీని నిశితంగా పరిశీలిస్తాము. కథనాన్ని అర్థం చేసుకోవడానికి, మీకు APIలు మరియు పైథాన్తో పని చేయడం గురించి ప్రాథమిక జ్ఞానం అవసరం.
చెక్ పాయింట్ APIని చురుకుగా అభివృద్ధి చేస్తోంది మరియు ప్రస్తుతం కిందివి విడుదల చేయబడ్డాయి:
- - API ద్వారా నియంత్రణ సర్వర్తో పని చేయండి (మరియు కంట్రోల్ సర్వర్ ద్వారా నియంత్రించబడే గేట్వేలపై స్క్రిప్ట్లను అమలు చేయగల సామర్థ్యం)
- - భద్రతా గేట్వేలతో పని చేయండి
- — చెక్ పాయింట్ క్లౌడ్లోని శాండ్బాక్స్తో పని చేస్తోంది
- - గేట్వేలపై ఐడెంటిటీ అవేర్నెస్ బ్లేడ్తో పని చేయడం
- - SMB గేట్వే మేనేజ్మెంట్ పోర్టల్తో పని చేయండి ()
- - IoT కంట్రోలర్లతో పరస్పర చర్య
- -తో పని చేయండి (SD-WAN భద్రతా పరిష్కారం)
- -తో పని చేయండి
పైథాన్ SDK ప్రస్తుతం నిర్వహణ API మరియు పరస్పర చర్యకు మాత్రమే మద్దతు ఇస్తుంది గియా API. మేము ఈ మాడ్యూల్లోని అత్యంత ముఖ్యమైన తరగతులు, పద్ధతులు మరియు వేరియబుల్లను పరిశీలిస్తాము.
మాడ్యూల్ను ఇన్స్టాల్ చేస్తోంది
మాడ్యూల్ cpapi నుండి త్వరగా మరియు సులభంగా ఇన్స్టాల్ చేస్తుంది సహాయంతో విత్తనము. వివరణాత్మక ఇన్స్టాలేషన్ సూచనలు అందుబాటులో ఉన్నాయి . ఈ మాడ్యూల్ పైథాన్ సంస్కరణలు 2.7 మరియు 3.7తో పని చేయడానికి స్వీకరించబడింది. ఈ వ్యాసంలో, పైథాన్ 3.7 ఉపయోగించి ఉదాహరణలు ఇవ్వబడతాయి. అయినప్పటికీ, పైథాన్ SDK నేరుగా చెక్ పాయింట్ మేనేజ్మెంట్ సర్వర్ (స్మార్ట్ మేనేజ్మెంట్) నుండి అమలు చేయబడుతుంది, కానీ అవి పైథాన్ 2.7కి మాత్రమే మద్దతిస్తాయి, కాబట్టి చివరి విభాగం వెర్షన్ 2.7 కోసం కోడ్ను అందిస్తుంది. మాడ్యూల్ను ఇన్స్టాల్ చేసిన వెంటనే, డైరెక్టరీలలోని ఉదాహరణలను చూడమని నేను సిఫార్సు చేస్తున్నాను ఉదాహరణలు_పైథాన్2 и ఉదాహరణలు_పైథాన్3.
ప్రారంభ విధానం
మేము cpapi మాడ్యూల్ యొక్క భాగాలతో పని చేయగలిగేలా చేయడానికి, మేము మాడ్యూల్ నుండి దిగుమతి చేసుకోవాలి cpapi కనీసం రెండు అవసరమైన తరగతులు:
APClient и APIClientArgs
from cpapi import APIClient, APIClientArgs
Класс APIClientArgs API సర్వర్ మరియు తరగతికి కనెక్షన్ పారామితులకు బాధ్యత వహిస్తుంది APClient APIతో పరస్పర చర్యకు బాధ్యత వహిస్తుంది.
కనెక్షన్ పారామితులను నిర్ణయించడం
APIకి కనెక్ట్ చేయడానికి వివిధ పారామితులను నిర్వచించడానికి, మీరు తరగతి యొక్క ఉదాహరణను సృష్టించాలి APIClientArgs. సూత్రప్రాయంగా, దాని పారామితులు ముందే నిర్వచించబడ్డాయి మరియు నియంత్రణ సర్వర్లో స్క్రిప్ట్ను అమలు చేస్తున్నప్పుడు, అవి పేర్కొనవలసిన అవసరం లేదు.
client_args = APIClientArgs()కానీ థర్డ్-పార్టీ హోస్ట్లో నడుస్తున్నప్పుడు, మీరు కనీసం IP చిరునామా లేదా API సర్వర్ యొక్క హోస్ట్ పేరుని పేర్కొనాలి (నిర్వహణ సర్వర్ అని కూడా పిలుస్తారు). దిగువ ఉదాహరణలో, మేము సర్వర్ కనెక్షన్ పరామితిని నిర్వచించాము మరియు నిర్వహణ సర్వర్ యొక్క IP చిరునామాను స్ట్రింగ్గా కేటాయిస్తాము.
client_args = APIClientArgs(server='192.168.47.241')API సర్వర్కు కనెక్ట్ చేసేటప్పుడు ఉపయోగించగల అన్ని పారామితులను మరియు వాటి డిఫాల్ట్ విలువలను చూద్దాం:
APIClientArgs తరగతి యొక్క __init__ పద్ధతి యొక్క వాదనలు
class APIClientArgs:
"""
This class provides arguments for APIClient configuration.
All the arguments are configured with their default values.
"""
# port is set to None by default, but it gets replaced with 443 if not specified
# context possible values - web_api (default) or gaia_api
def __init__(self, port=None, fingerprint=None, sid=None, server="127.0.0.1", http_debug_level=0,
api_calls=None, debug_file="", proxy_host=None, proxy_port=8080,
api_version=None, unsafe=False, unsafe_auto_accept=False, context="web_api"):
self.port = port
# management server fingerprint
self.fingerprint = fingerprint
# session-id.
self.sid = sid
# management server name or IP-address
self.server = server
# debug level
self.http_debug_level = http_debug_level
# an array with all the api calls (for debug purposes)
self.api_calls = api_calls if api_calls else []
# name of debug file. If left empty, debug data will not be saved to disk.
self.debug_file = debug_file
# HTTP proxy server address (without "http://")
self.proxy_host = proxy_host
# HTTP proxy port
self.proxy_port = proxy_port
# Management server's API version
self.api_version = api_version
# Indicates that the client should not check the server's certificate
self.unsafe = unsafe
# Indicates that the client should automatically accept and save the server's certificate
self.unsafe_auto_accept = unsafe_auto_accept
# The context of using the client - defaults to web_api
self.context = contextAPIClientArgs క్లాస్లోని సందర్భాలలో ఉపయోగించబడే ఆర్గ్యుమెంట్లు చెక్ పాయింట్ అడ్మినిస్ట్రేటర్లకు సహజమైనవని మరియు అదనపు వ్యాఖ్యలు అవసరం లేదని నేను నమ్ముతున్నాను.
APClient మరియు కాంటెక్స్ట్ మేనేజర్ ద్వారా కనెక్ట్ అవుతోంది
Класс 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_కాల్ и api_query, మేము వాటి గురించి కొంచెం ముందుకు మాట్లాడుతాము) API సర్వర్లో sha1 వేలిముద్ర ప్రమాణపత్రం. అయితే, API సర్వర్ సర్టిఫికేట్ యొక్క sha1 వేలిముద్రను తనిఖీ చేస్తున్నప్పుడు, లోపం గుర్తించబడితే (సర్టిఫికేట్ తెలియదు లేదా మార్చబడింది), పద్ధతి తనిఖీ_వేలిముద్ర స్థానిక మెషీన్లో దాని గురించి సమాచారాన్ని స్వయంచాలకంగా జోడించడానికి/మార్చడానికి అవకాశాన్ని అందిస్తుంది. ఈ తనిఖీని పూర్తిగా నిలిపివేయవచ్చు (కానీ 127.0.0.1కి కనెక్ట్ చేస్తున్నప్పుడు, API సర్వర్లోనే స్క్రిప్ట్లు అమలు చేయబడితే మాత్రమే ఇది సిఫార్సు చేయబడుతుంది), APIClientArgs ఆర్గ్యుమెంట్ ఉపయోగించి - అసురక్షిత_ఆటో_అంగీకరించు (“కనెక్షన్ పారామితులను నిర్వచించడం”లో ముందుగా APIClientArgs గురించి మరింత చూడండి).
client_args = APIClientArgs(unsafe_auto_accept=True)API సర్వర్కి లాగిన్ చేయండి
У APClient API సర్వర్లోకి లాగిన్ చేయడానికి అనేక 3 పద్ధతులు ఉన్నాయి మరియు వాటిలో ప్రతి ఒక్కటి అర్థాన్ని అర్థం చేసుకుంటుంది సిడ్(సెషన్-ఐడి), ఇది హెడర్లోని ప్రతి తదుపరి API కాల్లో స్వయంచాలకంగా ఉపయోగించబడుతుంది (ఈ పరామితి యొక్క హెడర్లోని పేరు X-chkp-sid), కాబట్టి ఈ పరామితిని మరింత ప్రాసెస్ చేయవలసిన అవసరం లేదు.
లాగిన్ పద్ధతి
లాగిన్ మరియు పాస్వర్డ్ని ఉపయోగించే ఎంపిక (ఉదాహరణలో, వినియోగదారు పేరు అడ్మిన్ మరియు పాస్వర్డ్ 1q2w3e స్థాన వాదనలుగా ఆమోదించబడ్డాయి):
login = client.login('admin', '1q2w3e') లాగిన్ పద్ధతిలో అదనపు ఐచ్ఛిక పారామితులు కూడా అందుబాటులో ఉన్నాయి, వాటి పేర్లు మరియు డిఫాల్ట్ విలువలు ఇక్కడ ఉన్నాయి:
continue_last_session=False, domain=None, read_only=False, payload=NoneApi_key పద్ధతితో_లాగిన్ చేయండి
Api కీని ఉపయోగించే ఎంపిక (నిర్వహణ వెర్షన్ R80.40/Management API v1.6 నుండి మద్దతు ఉంది, "3TsbPJ8ZKjaJGvFyoFqHFA==" ఇది API కీ అధికార పద్ధతితో నిర్వహణ సర్వర్లోని వినియోగదారులలో ఒకరికి API కీ విలువ:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==') పద్ధతిలో api_కీతో_లాగిన్ చేయండి పద్ధతిలో వలె అదే ఐచ్ఛిక పారామితులు అందుబాటులో ఉన్నాయి లాగిన్.
login_as_root పద్ధతి
API సర్వర్తో స్థానిక మెషీన్కు లాగిన్ చేయడానికి ఎంపిక:
login = client.login_as_root()ఈ పద్ధతికి రెండు ఐచ్ఛిక పారామితులు మాత్రమే అందుబాటులో ఉన్నాయి:
domain=None, payload=Noneచివరకు API తమను తాము పిలుస్తుంది
పద్ధతుల ద్వారా API కాల్లు చేయడానికి మాకు రెండు ఎంపికలు ఉన్నాయి api_కాల్ и api_query. వాటి మధ్య తేడా ఏమిటో తెలుసుకుందాం.
api_కాల్
ఈ పద్ధతి ఏదైనా కాల్లకు వర్తిస్తుంది. అవసరమైతే మేము అభ్యర్థన బాడీలో api కాల్ మరియు పేలోడ్ కోసం చివరి భాగాన్ని పాస్ చేయాలి. పేలోడ్ ఖాళీగా ఉంటే, అది అస్సలు బదిలీ చేయబడదు:
api_versions = client.api_call('show-api-versions') కట్ క్రింద ఈ అభ్యర్థన కోసం అవుట్పుట్:
In [23]: api_versions
Out[23]:
APIResponse({
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"res_obj": {
"data": {
"current-version": "1.6",
"supported-versions": [
"1",
"1.1",
"1.2",
"1.3",
"1.4",
"1.5",
"1.6"
]
},
"status_code": 200
},
"status_code": 200,
"success": true
})
show_host = client.api_call('show-host', {'name' : 'h_8.8.8.8'})కట్ క్రింద ఈ అభ్యర్థన కోసం అవుట్పుట్:
In [25]: show_host
Out[25]:
APIResponse({
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"res_obj": {
"data": {
"color": "black",
"comments": "",
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"groups": [],
"icon": "Objects/host",
"interfaces": [],
"ipv4-address": "8.8.8.8",
"meta-info": {
"creation-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"creator": "admin",
"last-modifier": "admin",
"last-modify-time": {
"iso-8601": "2020-05-01T21:49+0300",
"posix": 1588358973517
},
"lock": "unlocked",
"validation-state": "ok"
},
"name": "h_8.8.8.8",
"nat-settings": {
"auto-rule": false
},
"read-only": false,
"tags": [],
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
},
"status_code": 200
},
"status_code": 200,
"success": true
})
api_query
అవుట్పుట్ ఆఫ్సెట్తో కూడిన కాల్లకు మాత్రమే ఈ పద్ధతి వర్తిస్తుందని నేను వెంటనే రిజర్వేషన్ చేయనివ్వండి. అటువంటి అనుమితి అది పెద్ద మొత్తంలో సమాచారాన్ని కలిగి ఉన్నప్పుడు లేదా కలిగి ఉండవచ్చు. ఉదాహరణకు, నిర్వహణ సర్వర్లో సృష్టించబడిన అన్ని హోస్ట్ ఆబ్జెక్ట్ల జాబితా కోసం ఇది అభ్యర్థన కావచ్చు. అటువంటి అభ్యర్థనల కోసం, API డిఫాల్ట్గా 50 ఆబ్జెక్ట్ల జాబితాను అందిస్తుంది (మీరు ప్రతిస్పందనలో పరిమితిని 500 ఆబ్జెక్ట్లకు పెంచవచ్చు). మరియు API అభ్యర్థనలో ఆఫ్సెట్ పరామితిని మార్చడం ద్వారా సమాచారాన్ని చాలాసార్లు లాగకుండా ఉండటానికి, ఈ పనిని స్వయంచాలకంగా చేసే api_query పద్ధతి ఉంది. ఈ పద్ధతి అవసరమైన కాల్ల ఉదాహరణలు: షో-సెషన్లు, షో-హోస్ట్లు, షో-నెట్వర్క్లు, షో-వైల్డ్కార్డ్లు, షో-గ్రూప్లు, షో-అడ్రస్-పరిధులు, షో-సింపుల్-గేట్వేలు, షో-సింపుల్-క్లస్టర్లు, షో-యాక్సెస్-రోల్స్, షో-ట్రస్టెడ్-క్లయింట్లు ప్రదర్శన-ప్యాకేజీలు. వాస్తవానికి, మేము ఈ API కాల్ల పేరులో బహువచన పదాలను చూస్తాము, కాబట్టి ఈ కాల్లను నిర్వహించడం సులభం అవుతుంది api_query
show_hosts = client.api_query('show-hosts') కట్ క్రింద ఈ అభ్యర్థన కోసం అవుట్పుట్:
In [21]: show_hosts
Out[21]:
APIResponse({
"data": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"res_obj": {
"data": {
"from": 1,
"objects": [
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "192.168.47.1",
"name": "h_192.168.47.1",
"type": "host",
"uid": "5d7d7086-d70b-4995-971a-0583b15a2bfc"
},
{
"domain": {
"domain-type": "domain",
"name": "SMC User",
"uid": "41e821a0-3720-11e3-aa6e-0800200c9fde"
},
"ipv4-address": "8.8.8.8",
"name": "h_8.8.8.8",
"type": "host",
"uid": "c210af07-1939-49d3-a351-953a9c471d9e"
}
],
"to": 2,
"total": 2
},
"status_code": 200
},
"status_code": 200,
"success": true
})
API కాల్ల ఫలితాలను ప్రాసెస్ చేస్తోంది
దీని తరువాత మీరు తరగతి యొక్క వేరియబుల్స్ మరియు పద్ధతులను ఉపయోగించవచ్చు APIRస్పందన(సందర్భ నిర్వాహకుడు లోపల మరియు వెలుపల). తరగతి వద్ద APIRస్పందన 4 పద్ధతులు మరియు 5 వేరియబుల్స్ ముందే నిర్వచించబడ్డాయి;
విజయం
ప్రారంభించడానికి, API కాల్ విజయవంతమైందని మరియు ఫలితాన్ని అందించిందని నిర్ధారించుకోవడం మంచిది. దీనికి ఒక పద్ధతి ఉంది విజయం:
In [49]: api_versions.success
Out[49]: True
API కాల్ విజయవంతమైతే ఒప్పు (ప్రతిస్పందన కోడ్ - 200) మరియు విజయవంతం కాకపోతే తప్పు (ఏదైనా ఇతర ప్రతిస్పందన కోడ్) చూపుతుంది. ప్రతిస్పందన కోడ్పై ఆధారపడి విభిన్న సమాచారాన్ని ప్రదర్శించడానికి API కాల్ తర్వాత వెంటనే ఉపయోగించడం సౌకర్యంగా ఉంటుంది.
if api_ver.success:
print(api_versions.data)
else:
print(api_versions.err_message) స్థితి కోడ్
API కాల్ చేసిన తర్వాత ప్రతిస్పందన కోడ్ను అందిస్తుంది.
In [62]: api_versions.status_code
Out[62]: 400
సాధ్యమైన ప్రతిస్పందన కోడ్లు: 200,400,401,403,404,409,500,501.
సెట్_సక్సెస్_స్టేటస్
ఈ సందర్భంలో, విజయ స్థితి యొక్క విలువను మార్చడం అవసరం కావచ్చు. సాంకేతికంగా, మీరు అక్కడ ఏదైనా ఉంచవచ్చు, సాధారణ స్ట్రింగ్ కూడా. కానీ కొన్ని పరిస్థితులలో ఈ పరామితిని తప్పుకు రీసెట్ చేయడం నిజమైన ఉదాహరణ. దిగువన, నిర్వహణ సర్వర్లో టాస్క్లు నడుస్తున్నప్పుడు ఉదాహరణకి శ్రద్ధ వహించండి, కానీ మేము ఈ అభ్యర్థన విజయవంతం కాలేదని పరిగణిస్తాము (మేము సక్సెస్ వేరియబుల్ని సెట్ చేస్తాము తప్పుడు, API కాల్ విజయవంతమై, కోడ్ 200ని అందించినప్పటికీ).
for task in task_result.data["tasks"]:
if task["status"] == "failed" or task["status"] == "partially succeeded":
task_result.set_success_status(False)
breakప్రతిస్పందన ()
ప్రతిస్పందన పద్ధతి మీరు ప్రతిస్పందన కోడ్ (status_code) మరియు ప్రతిస్పందన శరీరం (శరీరం)తో నిఘంటువును వీక్షించడానికి అనుమతిస్తుంది.
In [94]: api_versions.response()
Out[94]:
{'status_code': 200,
'data': {'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}}
సమాచారం
అనవసరమైన సమాచారం లేకుండా ప్రతిస్పందన (శరీరం) యొక్క శరీరాన్ని మాత్రమే చూడటానికి మిమ్మల్ని అనుమతిస్తుంది.
In [93]: api_versions.data
Out[93]:
{'current-version': '1.6',
'supported-versions': ['1', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']}
లోపం_సందేశం
API అభ్యర్థనను ప్రాసెస్ చేస్తున్నప్పుడు లోపం సంభవించినప్పుడు మాత్రమే ఈ సమాచారం అందుబాటులో ఉంటుంది (స్పందన కోడ్ కాదు 200) ఉదాహరణ అవుట్పుట్
In [107]: api_versions.error_message
Out[107]: 'code: generic_err_invalid_parameter_namenmessage: Unrecognized parameter [1]n'
ఉపయోగకరమైన ఉదాహరణలు
నిర్వహణ API 1.6లో జోడించబడిన API కాల్లను ఉపయోగించే ఉదాహరణలు క్రిందివి.
ముందుగా, కాల్లు ఎలా పని చేస్తాయో చూద్దాం యాడ్-హోస్ట్ и జోడించు-చిరునామా-పరిధి. మేము సబ్నెట్ 192.168.0.0/24 యొక్క అన్ని IP చిరునామాలను సృష్టించాలని అనుకుందాం, వీటిలో చివరి ఆక్టెట్ 5, హోస్ట్ రకం యొక్క వస్తువులుగా మరియు అన్ని ఇతర IP చిరునామాలను చిరునామా పరిధి రకం యొక్క వస్తువులుగా వ్రాయండి. ఈ సందర్భంలో, సబ్నెట్ చిరునామా మరియు ప్రసార చిరునామాను మినహాయించండి.
కాబట్టి, ఈ సమస్యను పరిష్కరించే స్క్రిప్ట్ క్రింద ఉంది మరియు హోస్ట్ రకం యొక్క 50 ఆబ్జెక్ట్లను మరియు చిరునామా పరిధి రకం 51 ఆబ్జెక్ట్లను సృష్టిస్తుంది. సమస్యను పరిష్కరించడానికి, 101 API కాల్లు అవసరం (చివరి ప్రచురణ కాల్ను లెక్కించడం లేదు). అలాగే, టైమ్ఇట్ మాడ్యూల్ని ఉపయోగించి, మార్పులు ప్రచురించబడే వరకు స్క్రిప్ట్ని అమలు చేయడానికి పట్టే సమయాన్ని మేము లెక్కిస్తాము.
యాడ్-హోస్ట్ మరియు యాడ్-అడ్రస్-రేంజ్ ఉపయోగించి స్క్రిప్ట్
import timeit
from cpapi import APIClient, APIClientArgs
start = timeit.default_timer()
first_ip = 1
last_ip = 4
client_args = APIClientArgs(server="192.168.47.240")
with APIClient(client_args) as client:
login = client.login_with_api_key('3TsbPJ8ZKjaJGvFyoFqHFA==')
for ip in range(5,255,5):
add_host = client.api_call("add-host", {"name" : f"h_192.168.0.{ip}", "ip-address": f'192.168.0.{ip}'})
while last_ip < 255:
add_range = client.api_call("add-address-range", {"name": f"r_192.168.0.{first_ip}-{last_ip}", "ip-address-first": f"192.168.0.{first_ip}", "ip-address-last": f"192.168.0.{last_ip}"})
first_ip+=5
last_ip+=5
stop = timeit.default_timer()
publish = client.api_call("publish")
print(f'Time to execute batch request: {stop - start} seconds')
నా ల్యాబ్ వాతావరణంలో, నిర్వహణ సర్వర్లోని లోడ్ను బట్టి ఈ స్క్రిప్ట్ అమలు చేయడానికి 30 మరియు 50 సెకన్ల మధ్య పడుతుంది.
ఇప్పుడు API కాల్ని ఉపయోగించి అదే సమస్యను ఎలా పరిష్కరించాలో చూద్దాం 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 రెట్లు వేగంగా నడుస్తుంది. పెద్ద సంఖ్యలో వస్తువులపై వ్యత్యాసం మరింత ఆకర్షణీయంగా ఉంటుంది.
ఇప్పుడు ఎలా పని చేయాలో చూద్దాం సెట్-వస్తువులు-బ్యాచ్. ఈ 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")
చెక్ పాయింట్ మేనేజ్మెంట్ సర్వర్లో పైథాన్ స్క్రిప్ట్లను అమలు చేస్తోంది
అంతా ఒకటే నియంత్రణ సర్వర్ నుండి నేరుగా పైథాన్ స్క్రిప్ట్లను ఎలా అమలు చేయాలి అనే సమాచారాన్ని కలిగి ఉంటుంది. మీరు మరొక యంత్రం నుండి 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","пароль","Пароль","Ключ","ключ","шифр","Шифр"]
}
తీర్మానం
ఈ వ్యాసం పని యొక్క ప్రాథమిక అవకాశాలను మాత్రమే పరిశీలిస్తుంది పైథాన్ SDK మరియు మాడ్యూల్ cpapi(మీరు ఊహించినట్లుగా, ఇవి వాస్తవానికి పర్యాయపదాలు), మరియు ఈ మాడ్యూల్లోని కోడ్ను అధ్యయనం చేయడం ద్వారా మీరు దానితో పని చేయడానికి మరిన్ని అవకాశాలను కనుగొంటారు. మీరు దీన్ని మీ స్వంత తరగతులు, విధులు, పద్ధతులు మరియు వేరియబుల్లతో భర్తీ చేయాలనుకునే అవకాశం ఉంది. విభాగంలో చెక్ పాయింట్ కోసం మీరు ఎప్పుడైనా మీ పనిని పంచుకోవచ్చు మరియు ఇతర స్క్రిప్ట్లను వీక్షించవచ్చు సంఘంలో , ఇది ఉత్పత్తి డెవలపర్లు మరియు వినియోగదారులు ఇద్దరినీ కలిపిస్తుంది.
సంతోషకరమైన కోడింగ్ మరియు చివరి వరకు చదివినందుకు ధన్యవాదాలు!
మూలం: www.habr.com
