Palo AltoPrismaSD-WANモニタリング

最終更新日: 15 年 2023 月 XNUMX 日

LogicMonitor の PaloAlto Prisma SD-WAN 監視パッケージは、Prisma SASE API を利用して ION を監視します。 これは、重要な ION の健全性とパフォーマンスのメトリクスを監視し、警告するように設計されています。

SNMP が有効になっている場合、次の Palo Alto Prisma SD-WAN Instant On (ION) フロー フォワーダー (旧称 CloudGenix) で追加の監視が利用可能です。

  • イオン1000シリーズ
  • イオン2000シリーズ
  • イオン3000シリーズ
  • イオン5000シリーズ
  • イオン7000シリーズ
  • イオン9000シリーズ
  • バーチャルイオンシリーズ

適切な SNMP 認証情報を使用すると、LogicMonitor Active Discovery は Prisma ION デバイスを自動的に検出し、次の SNMP ベースのデータソースを適用します。

  • CPU コア使用率
  • デバイス コンポーネント インベントリ
    • ハブ | 話した
  • ホストステータス
    • DNS
    • ホストステータス
    • ホスト稼働時間
  • ネットワークインターフェイス
  • ピン
  • 港-
  • システム レベルの IP 統計

詳細については、以下を参照してください 統合されたSASE SD-WAN API Palo AltoNetworks のドキュメント。

互換性

2023 年 1000 月の時点で、LogicMonitor の PaloAlto Prisma SD-WAN パッケージは、お客様が Palo Alto Networks の「Strata Cloud Manager」で管理する、ライセンスを取得した Prisma ION 2000、3000、5000、7000、9000、および XNUMX シリーズのデバイスまたは仮想アプライアンスと互換性があることが知られています。 。

要件

  • コレクター バージョン 32.400 以降
  • クライアント ID、クライアント シークレット、および TSG_ID。 *
    SASE API 認証情報の設定の詳細については、以下を参照してください。 Prisma SASE API の開始 パロアルトネットワークスのドキュメント。
  • インポートする LogicMonitor_Collector_Snippets DataSource : コレクターがこの監視スイートのコードをサポートしていることを確認します。
    または、EA Collector 32.100 以降に更新します。

モニタリングにリソースを追加する

次の方法を使用して、PaloAlto Prisma SD-WAN リソースをモニタリングに追加できます。

  • (推奨) 高度な NetScan
    詳細については、を参照してください。 ネットスキャンとは.
  • リソースを手動で追加する

高度な NetScan を使用してリソースを追加する

リソースは、拡張 NetScan スクリプトを使用して自動的に追加できます。 詳細については、「」を参照してください。 強化されたスクリプト ネットスキャン.

  1. あなたの中で ロジックモニターポータル > モジュール > 応募者と、Palo Alto Prisma SD-WAN モジュールをインストールします。 モジュールのリストについては、「パッケージ内の LogicModules」を参照してください。
  2. MFAデバイスに移動する  関連情報 > Add > 複数のデバイス > 高度なネットスキャンを選択します。 高度な NetScan を追加する ページが表示されます。
  3. この NetScan に関連付ける名前を入力します。 たとえば、「Palo Alto Prisma SD-WAN デバイス」です。
  4. NetScan を実行するコレクタを選択します。
    詳細については、を参照してください。 コレクターの割り当て in 強化されたスクリプト ネットスキャン.
  5. 選択 強化されたスクリプト NetScan   方法 ドロップダウンリスト。
  6. 「拡張スクリプト」セクションから、次を選択します。 デバイスの資格情報 > このスキャンにカスタム資格情報を使用する.
  7. NetScan に必要な Palo Alto Prisma SD-WAN 資格情報を提供する次のプロパティを追加し、NetScan がリソースを作成および編成する方法と場所を変更します。
プロパティ必須
paloalto.sase.client.idサービスアカウントクライアントID
詳細については、以下を参照してください サービスアカウント パロアルトネットワークスのドキュメント。
有り
paloalto.sase.client.keyサービスアカウントクライアントキー
詳細については、以下を参照してください サービスアカウント パロアルトネットワークスのドキュメント。
有り
paloalto.sase.tsg.idテナントサービスグル​​ープID
詳細については、以下を参照してください テナントサービスグル​​ープ パロアルトネットワークスのドキュメント。
有り
lmaccess.id またはlogicmonitor.access.idポータルにリソースを追加する前に NetScan で重複リソースを検索するための LogicMonitor API アクセス ID
ポータル監視の詳細については、次を参照してください。 LogicMonitorポータルモニタリング.
有り
lmaccess.key またはlogicmonitor.access.keyポータルにリソースを追加する前に NetScan で重複リソースを検索するための LogicMonitor API キー。
ポータル監視の詳細については、次を参照してください。 LogicMonitorポータルモニタリング.
有り
paloalto.prisma.sdwan.root.folderこの NetScan が作成するか、すでに存在する場合は使用する LogicMonitor リソース グループの名前。
値には、ネストされた子フォルダーを指定できます (例: folder/folder/folder).
デフォルトは「Palo Alto Prisma SDWAN」です。
動的デバイス グループは NetScans によって追加されないため、これを動的デバイス グループに割り当てないでください。
詳細については、を参照してください。 デバイスグループの概要.
いいえ
パロアルトコレクターデバイスに使用されるコレクター IDいいえ
スキップ.device.dedupeデバイスの重複排除チェックをスキップできるため、LogicMonitor API 認証情報が不要になります。いいえ
ホスト名.ソースNetScan で使用されるホスト名のソースを選択できます。
これは、既存のリソースに競合が見つかった場合に、重複したデバイスの作成を防ぐのに役立ちます。
いいえ
プリズマ.sdwan.sites.csvサイト名、コレクタ ID、およびサイト フォルダ名を含む CSV ファイルのパス。
CSV ファイルは、次の該当するパスの下に配置する必要があります。
  • (Linux) /usr/local/logicmonitor/agent/bin directory

  • (Windowsの場合) C:\Program Files\LogicMonitor\Agent\bin directory
  • いいえ
    1. 「Groovy スクリプトを埋め込む」を選択し、次のスクリプトを埋め込みます。

    警告: スクリプトを編集しないでください。 編集された拡張スクリプト NetScan はサポートされていません。 LogicMonitor が提供するスクリプトを編集した場合、問題が発生した場合、LogicMonitor サポートはサポートされているスクリプトで編集内容を上書きするよう要求する場合があります。 拡張スクリプト NetScan は、LM Envision リソースの作成を 600 時間あたり 600 以下に制限します。 XNUMX を超えるリソースを作成するには、すべてのリソースが追加されるまで NetScan を XNUMX 時間ごとに繰り返すようにスケジュールします。

    /*******************************************************************************
     * © 2007-2023 - LogicMonitor, Inc. All rights reserved.
     ******************************************************************************/
     
    import com.logicmonitor.common.sse.utils.GroovyScriptHelper as GSH
    import com.logicmonitor.mod.Snippets
    import com.santaba.agent.AgentVersion
    import java.text.DecimalFormat
    import groovy.json.JsonOutput
    import groovy.json.JsonSlurper
     
    // To run in debug mode, set to true
    Boolean debug = false
     
    // Set props object based on whether or not we are running inside a netscan or debug console
    def props
    try {
        hostProps.get("system.hostname")
        props = hostProps
        debug = true  // set debug to true so that we can ensure we do not print sensitive properties
    }
    catch (MissingPropertyException) {
        props = netscanProps
    }
     
    // Required properties
    def clientId = props.get("paloalto.sase.client.id")
    def clientSecret = props.get("paloalto.sase.client.key")
    def tsgId = props.get("paloalto.sase.tsg.id")
     
    // Optional properties
    def rootFolder = props.get("paloalto.prisma.sdwan.root.folder") ?: "Prisma SD-WAN"
    def collectorId = props.get("paloalto.collector")
     
    Boolean skipDeviceDedupe = props.get("skip.device.dedupe", "false").toBoolean()
    String hostnameSource = props.get("hostname.source", "")?.toLowerCase()?.trim()
     
    // Retrieve the collector version
    Integer collectorVersion = AgentVersion.AGENT_VERSION.toInteger()
     
    // Bail out early if we don't have the correct minimum collector version to ensure netscan runs properly
    if (collectorVersion < 32400) {
        def formattedVer = new DecimalFormat("00.000").format(collectorVersion / 1000)
        throw new Exception(" Upgrade collector running netscan to 32.400 or higher to run full featured enhanced script netscan. Currently running version ${formattedVer}.")
    }
     
    // Bail out early if we don't have the necessary credentials
    if (!clientSecret || !clientId || !tsgId) {
        throw new Exception("Must provide credentials to run this script (paloalto.sase.client.id, paloalto.sase.client.key, and paloalto.sase.tsg.id). Verify necessary credentials have been provided in NetScan properties.")
    }
     
    def modLoader = GSH.getInstance()._getScript("Snippets", Snippets.getLoader()).withBinding(getBinding())
    def lmEmit = modLoader.load("lm.emit", "1.1")
    def debugSnip = modLoader.load("lm.debug", "1.0")
    def lmDebug = debugSnip.debugSnippetFactory(out, debug)
    def httpSnippet = modLoader.load("proto.http", "0")
    def http = httpSnippet.httpSnippetFactory(props)
    def cache = modLoader.load("lm.cache", "0").cacheSnippetFactory(lmDebug, "PaloAlto_PrismaSDWAN")
    def prisma = modLoader.load("paloalto.prismasdwan", "0.0").prismaSnippetFactory(cache, http, lmDebug, props)
     
    // Only initialize lmApi snippet class if customer has not opted out
    def lmApi
    if (!skipDeviceDedupe) {
        def lmApiSnippet = modLoader.load("lm.api", "0")
        lmApi = lmApiSnippet.lmApiSnippetFactory(props, http, lmDebug)
    }
     
    String cacheFilename = "Technology_Primsa_devices"
     
    Map sensitiveProps = [
            "paloalto.sase.client.id" : clientId,
            "paloalto.sase.client.key": clientSecret,
    ]
     
    if (processResourcesJson(lmEmit, cacheFilename, sensitiveProps, lmDebug)) return 0
     
    // CSV file containing headers "Site ID" and "Site Name" to customize group names created
    // Save in /usr/local/logicmonitor/agent/bin directory (Linux)
    //  or C:\Program Files\LogicMonitor\Agent\bin directory (Windows)
    String csvFile = props.get("prisma.sdwan.sites.csv")
    // Convert to map with site ID as key
    Map siteInfo = csvFile ? processCSV(csvFile) : null
     
    // Get information about devices that already exist in LM portal
    List fields = ["name", "currentCollectorId", "displayName", "systemProperties"]
    Map args = ["size": 1000, "fields": fields.join(","), "filter": "systemProperties.name:\"system.sysname\""]
    def lmDevices
    // But first determine if the portal size is within a range that allows us to get all devices at once
    def pathFlag, portalInfo, timeLimitSec, timeLimitMs
    if (!skipDeviceDedupe) {
        portalInfo = lmApi.apiCallInfo("Devices", args)
        timeLimitSec = props.get("lmapi.timelimit.sec", "60").toInteger()
        timeLimitMs = (timeLimitSec) ? Math.min(Math.max(timeLimitSec, 30), 120) * 1000 : 60000
        // Allow range 30-120 sec if configured; default to 60 sec
     
        if (portalInfo.timeEstimateMs > timeLimitMs) {
            lmDebug.LMDebugPrint("Estimate indicates LM API calls would take longer than time limit configured.  Proceeding with individual queries by display name for each device to add.")
            lmDebug.LMDebugPrint("\t${portalInfo}\n\tNOTE:  Time limit is set to ${timeLimitSec} seconds.  Adjust this limit by setting the property lmapi.timelimit.sec.  Max 120 seconds, min 30 seconds.")
            pathFlag = "ind"
        } else {
            lmDebug.LMDebugPrint("Response time indicates LM API calls will complete in a reasonable time range.  Proceeding to collect info on all devices to cross reference and prevent duplicate device creation.\n\t${portalInfo}")
            pathFlag = "all"
            lmDevices = lmApi.getPortalDevices(args)
        }
    }
     
    def lmDevicesBySysname
    if (pathFlag == "all" && !skipDeviceDedupe) {
        // Prisma does not provide individual IP addresses, check dedupe by device name
        lmDevicesBySysname = lmDevices?.collectEntries { device ->
            def sysName = device.systemProperties.find { it -> it.name == "system.sysname" }.value
            [
                    ("${sysName}".toString().toLowerCase()): [
                            "name"              : "${device.name}",
                            "displayName"       : (device.displayName),
                            "currentCollectorId": (device.currentCollectorId),
                            "sysName"           : (sysName)
                    ]
            ]
        }
     
    }
    // Get your data and build your list of resources
    List<Map> resources = []
     
    def now = new Date()
    def dateFormat = "yyyy-MM-dd'T'HH:mm:ss.s z"
    TimeZone tz = TimeZone.getDefault()
    Map duplicateResources = [
            "date"     : now.format(dateFormat, tz),
            "message"  : "Duplicate display names found within LogicMonitor portal wherein hostname in LM does not match hostname in Netscan output.  Refer to documentation for how to resolve name collisions using 'hostname.source' netscan property.",
            "total"    : 0,
            "resources": []
    ]
     
     
    if (!prisma.token) {
        throw new Exception("Credential check failed. Verify credentials and try running in debug mode in collector debug console.")
    }
     
    def permissions = prisma.getPermissions()
    def siteVersion = prisma.sanitizeVersion(permissions.resource_version_map.sites)
            ?.split(",")?.max()
    def elementVersion = prisma.sanitizeVersion(permissions.resource_version_map.elements)
            ?.split(",")?.max()
     
    Map sites = prisma.getSites(siteVersion)?.collectEntries { site -> [(site.id): (site.name)] }
    def elements = prisma.getElements(elementVersion)
    elements?.each { details ->
        def displayName = details.name
        def displayNameToCheck = "${displayName}".toString().toLowerCase()
        // We do not get IP for prisma
        def hostName = details.name
        // Check for existing device in LM portal with this displayName; set to false initially and update to true when dupe found
        def deviceMatch = false
        def elementId = details.id
     
        // If customer has opted out of device deduplication checks, we skip the lookups where we determine if a match exists and proceed as false
        if (!skipDeviceDedupe) {
            if (pathFlag == "ind") {
                deviceMatch = lmApi.findPortalDeviceByProperty(displayName, args)
            } else if (pathFlag == "all") {
                deviceMatch = lmDevicesBySysname?.get(displayName)
            }
        }
     
        if (deviceMatch) {
            // Log duplicates that would cause additional devices to be created; unless these entries are resolved, they will not be added to resources for netscan output
            // We have a collision if the element name is the same as the hostname from the existing lm resource
            if (displayNameToCheck != deviceMatch.name.toString().toLowerCase()) {
                def collisionInfo = [
                        (displayNameToCheck): [
                                "Netscan" : [
                                        "hostname": hostName
                                ],
                                "LM"      : [
                                        "hostname"   : deviceMatch.name,
                                        "collectorId": deviceMatch.currentCollectorId
                                ],
                                "Resolved": false
                        ]
                ]
     
                // If user specified to use LM hostname on display name match, update hostname variable accordingly
                // need to figure out the logic here if a customer chooses lm do we pick the hostname as display name ?
                if (hostnameSource == "lm" || hostnameSource == "logicmonitor") {
                    collisionInfo[displayNameToCheck]["Resolved"] = true
                    hostName = deviceMatch.name
                    displayName = deviceMatch.displayName
                    collectorId = deviceMatch.currentCollectorId
                    deviceMatch = false
     
                }
                // If user specified to use netscan data for hostname, update the display name to make it unique
                // and flag it as no longer a match since we have resolved the collision with user's input
                else if (hostnameSource == "netscan") {
                    collisionInfo[displayNameToCheck]["Resolved"] = true
                    displayName = "${displayName} - ${deviceMatch.name}"
                    deviceMatch = false
                }
     
                duplicateResources["resources"].add(collisionInfo)
            }
            // Don't worry about matches where the hostname values are the same
            // These will update via normal netscan processing and should be ignored
            else {
                deviceMatch = false
            }
        }
     
        String siteId = "${details.site_id}"
        List groupName = null
        if (siteInfo) {
            if (siteInfo[sites?.get(siteId)]) {
                groupName = ["${rootFolder}/${siteInfo[sites?.get(siteId)]}"]
            }
        } else {
            def site = sites?.get(siteId)
            groupName = site ? ["${rootFolder}/${site}"] : ["${rootFolder}"]
        }
     
        Map hostProps = ["paloalto.sase.element.id": elementId,
                         "paloalto.sase.tsg.id"    : tsgId
        ]
     
        sensitiveProps.each { k, v ->
            hostProps.put(k, v)
        }
     
        Map resource = [
                "hostname"   : hostName.replaceAll(/[!@#$%^&*()+={}\[\]|\\\\;'"<>,\/?`~ ]/, '-'),  // String
                "displayname": displayName, // String
                "hostProps"  : hostProps, // Map<String, String>
                "groupName"  : groupName,   // List<String>
        ]
     
        if (collectorId) {
            resource["collectorId"] = collectorId
            if(duplicateResources["resources"][displayNameToCheck]["Netscan"][0]){
                duplicateResources["resources"][displayNameToCheck]["Netscan"][0]["collectorId"] = collectorId
            }
        }
     
        if (!deviceMatch) {
            resources.add(resource)
        }
    }
     
    // Output validated data in JSON format
    // If errors have been made in acceptable/required keys, lm.emit will throw and inform the user
    emitWriteJsonResources(lmEmit, cacheFilename, resources, lmDebug) // limit output to 600
     
    // Report devices that already exist in LM via log file named after root folder
    if (duplicateResources["resources"].size() > 0) {
        def netscanDupLog = new File("../logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json")
        new File(netscanDupLog.getParent()).mkdirs()
        duplicateResources["total"] = duplicateResources["resources"].size()
        def json = JsonOutput.prettyPrint(JsonOutput.toJson(duplicateResources))
        netscanDupLog.write(json)
        if (hostnameSource) {
            lmDebug.LMDebug("${duplicateResources["resources"].size()} devices found that were resolved with hostname.source=${hostnameSource} in netscan output.  See LogicMonitor/Agent/logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json for details.")
        } else {
            lmDebug.LMDebug("${duplicateResources["resources"].size()} devices found that were not reported in netscan output.  See LogicMonitor/Agent/logs/NetscanDuplicates/${rootFolder.replaceAll(" ", "_")}.json for details.")
        }
    }
     
    return 0
     
    /**
     * Sanitizes filepath and instantiates File object
     * @param filename String
     * @param fileExtension String
     * @return File object using sanitized relative filepath
     */
    File newFile(String filename, String fileExtension) {
        // Ensure relative filepath is complete with extension type
        def filepath
        if (!filename?.startsWith("./")) {
            filepath = "./${filename}"
        }
        if (!filepath?.endsWith(".${fileExtension}")) {
            filepath = "${filepath}.${fileExtension}"
        }
     
        return new File(filepath)
    }
     
     
    ////////////////////////////////////////////////////////////// DEVICE BATCHING METHODS //////////////////////////////////////////////////////////////
    /**
     * Replaces cached props stored with bogus values with their correct values
     * @param cachedProps Map of hostProps values stored in file cache
     * @param sensitiveProps Map of sensitive properties configured in the netscan to use for updating cachedProps values
     * @return completeHostProps Map updated hostProps with no bogus values
     */
    Map processCachedHostProps(Map cachedProps, Map sensitiveProps) {
        Map completeHostProps = cachedProps.collectEntries { k, v ->
            if (sensitiveProps.containsKey(k)) {
                return [k as String, sensitiveProps[k]]
            } else {
                return [k as String, v as String]
            }
        }
        // Verify that we do not have any remaining properties with fake values; stop the show if we do
        def missingKeys = completeHostProps.findAll { k, v -> v == "***" }
        if (missingKeys) {
            throw new Exception(" Unable to update all cached sensitive properties with appropriate values.  Check Netscan properties and ensure the following keys have been added with values other than ***:\n\t${missingKeys.keySet().join(",")}")
        }
        return completeHostProps
    }
     
     
    /**
     * Processes a JSON file representing resources cached to disk on the collector
     * @param emit Snippet object for lm.emit (requires version 1.0)
     * @param filename String
     * @param sensitiveProps Map of sensitive properties configured in the netscan to use for updating cachedProps values
     * @param lmDebug Snippet object class instantiation of lm.debug (requires version 1.0)
     * @return Boolean indicator of whether processing was successful
     */
    Boolean processResourcesJson(emit, String filename, Map sensitiveProps, lmDebug) {
        File cacheFile = newFile(filename, "json")
        def cachedDevices
        try {
            cachedDevices = new JsonSlurper().parse(cacheFile)
        }
        catch (JsonException) {
            lmDebug.LMDebugPrint("No file found under ${cacheFile.name}; proceeding with API calls to retrieve devices.\n")
            return false
        }
     
        if (!cachedDevices) {
            lmDebug.LMDebugPrint("No cached devices found in ${cacheFile.name}; proceeding with API calls to retrieve devices.\n")
            return false
        }
        lmDebug.LMDebugPrint("${cachedDevices.size()} devices retrieved from cache file ${cacheFile.name}")
     
        // Updated cached devices to include proper values for sensitive properties stored in cache
        cachedDevices.each { device ->
            if (device["hostProps"]) device["hostProps"] = processCachedHostProps(device["hostProps"], sensitiveProps)
        }
     
        emitWriteJsonResources(emit, filename, cachedDevices, lmDebug)
        return true
    }
     
     
    /**
     * Output resources to stdout and cache any remainders to JSON file on collector disk
     * @param emit Snippet object for lm.emit (requires version 1.0)
     * @param filename String
     * @param resources List<Map> resources to be added from netscan
     * @param lmDebug Snippet object class instantiation of lm.debug (requires version 1.0)
     */
    def emitWriteJsonResources(emit, String filename, List<Map> resources, lmDebug) {
        def chunkSize = 600
        def chunk = Math.min(resources.size(), chunkSize)
        lmDebug.LMDebugPrint("Adding ${chunk} devices.")
        // Output resources in chunk size deemed safe by platform team
        emit.resource(resources[0..chunk - 1], lmDebug.debug)
     
        File cacheFile = newFile(filename, "json")
        // If the number of resources is less than or equal to our chunk size, our batching is complete and we can delete the file and exit
        if (resources.size() <= chunk) {
            cacheFile.delete()
            lmDebug.LMDebugPrint("All known devices have been reported.")
            return
        }
        // Remove sensitive properties prior to storing data in cache file; hardcode to true to ensure props are masked regardless of debug mode
        def remainingResources = emit.sanitizeResourceSensitiveProperties(resources, true)
        remainingResources = remainingResources[chunk..-1]
        def jsonRR = JsonOutput.toJson(remainingResources)
        // println JsonOutput.prettyPrint(jsonRR) // Uncomment for debugging purposes if needed
     
        lmDebug.LMDebug("Caching ${remainingResources.size()} devices to disk to add to portal in upcoming netscan executions.")
        cacheFile.write(jsonRR)
        return
    }
    ///////////////////////////////////////////////////////////////////// END //////////////////////////////////////////////////////////////////////
     
    ////////////////////////////////////////////////////////////// CSV PROCESSING METHODS ///////////////////////////////////////////////////////////
    /**
     * Helper function to process CSV with site id and name info
     * @param String filename Filename of the CSV containing user-defined site info
     * @return Map siteInfo with site ID as the key and site name as the value
     */
    Map processCSV(String filename) {
        File cacheFile = newFile(filename, "csv")
        def rows = cacheFile.readLines()*.split(",")
     
        def siteInfo = [:]
     
        // Verify whether headers are present and expected values
        // Sanitize for casing and extra whitespaces while gathering headers
        def maybeHeaders = rows[0]*.toLowerCase()*.trim()
        if (maybeHeaders.contains("site folder name") && maybeHeaders.contains("site name")) {
            Map headerIndices = [:]
            maybeHeaders.eachWithIndex { val, i ->
                headerIndices[val] = i
            }
            // Index values for headers to ensure we key the correct index regardless of order
            def sn = headerIndices["site name"]
            def colId = headerIndices["collector id"]
            def sf = headerIndices["site folder name"]
     
            // Remove headers from dataset
            data = rows[1..-1]
            // Build a map of common site names with site name as key
            data.each { entry ->
                siteInfo[entry[sn]] = [
                        "SiteFolder" : entry[sf],
                        "CollectorId": entry[colId]
                ]
            }
        }
        // Bail out early if we don't have the expected headers in the provided CSV, we can't properly associate Site IDs with common names without clear headers
        else {
            throw new Exception(" Required headers not provided in CSV.  Please provide \"Site Folder Name\" and \"Site Name\" (case insensitive).  Headers provided: \"${rows[0]}\"")
        }
        return siteInfo
    }
    ///////////////////////////////////////////////////////////////////// END //////////////////////////////////////////////////////////////////////
    
    1. 「スケジュール」セクションで、次を選択します。 このNetScanをスケジュールに従って実行する.
      動的環境の場合、NetScan を XNUMX 時間ごとに実行するようにスケジュールできます。
    2. 選択 Save or 保存して実行.

    NetScan を実行した後、追加されたリソースの数、または NetScan がリソースを作成しない場合はエラー メッセージの履歴を確認します。

    リソースを手動で追加する

    1. PaloAlto Prisma SD-WAN 組織デバイス グループを作成します。 詳細については、「」を参照してください。 デバイスグループの追加.
    2. デバイスを PaloAlto Prisma SD-WAN 組織グループに追加します。
    3. 次のプロパティがリソース上または Palo Alto Prisma 組織リソース グループの下に設定されていることを追加または確認します。 プロパティの設定の詳細については、を参照してください。 リソースとインスタンスのプロパティ.
    プロパティ
    paloalto.sase.client.idサービス アカウント クライアント ID 詳細については、「 サービスアカウント パロアルトネットワークスのドキュメント。
    paloalto.sase.client.keyサービス アカウント クライアント キー 詳細については、 サービスアカウント パロアルトネットワークスのドキュメント。
    paloalto.sase.tsg.idテナントサービスグル​​ープID

    LogicModulesをインポートする

    LogicMonitor パブリック リポジトリから、すべての Palto Alto Prisma SD-WAN LogicModules をインポートします。

    これらの LogicModule がすでにインストールされている場合は、最新バージョンであることを確認してください。

    LogicModule がインポートされると、データ収集が自動的に開始されます。 モジュールのインポートの詳細については、を参照してください。 LMエクスチェンジ.

    トラブルシューティング

    パッケージ内のLogicModules

    PaloAlto Prisma SD-WAN 用の LogicMonitor パッケージは、次の LogicModule で構成されています。 完全にカバーするには、次の LogicModule をプラットフォームにインポートします。

    表示名 説明
    PaloAlto_PrismaSDWAN_トポロジートポロジーソースPrisma トンネルと ION トポロジをマップします。
    Prisma SDWAN ヘルスデータソース各 SD-WAN ION の健全性を監視します。
    Prisma SDWAN オーバーレイデータソースION の VPN トンネルを監視します。
    Prisma SDWAN のパフォーマンスデータソースSD-WAN ION のパフォーマンスを監視します。
    Prisma SDWAN アンダーレイデータソースION の WAN 接続を監視します。
    addCategory_PaloAlto_PrismaSDWANプロパティソースシステム カテゴリ PaloAlto_PrismaSDWAN_Element と、関連するデバイス情報を含む自動プロパティを追加します。
    addERI_PaloAlto_PrismaSDWANプロパティソースPrisma ION の Prisma 固有の ERI を検出して追加します。

    このパッケージの DataSource によって追跡されるさまざまなメトリクスに静的なデータポイントのしきい値を設定する場合、LogicMonitor はテクノロジー所有者のベスト プラクティス KPI 推奨事項に従います。

    推奨事項: 必要に応じて、環境固有のニーズを満たすように事前定義されたしきい値を調整します。 データポイントのしきい値の調整の詳細については、を参照してください。 データポイントの静的しきい値の調整.

    記事上で