Naplókeresési riasztások létrehozása a Container Insightsból

  • Cikk

A Container Insights figyeli a felügyelt vagy önállóan felügyelt Kubernetes-fürtökön üzembe helyezett tárolókhoz kapcsolódó számítási feladatok teljesítményét. Ez a cikk azt ismerteti, hogyan hozhat létre naplóalapú riasztásokat az Azure Kubernetes Service-fürtökkel kapcsolatos következő helyzetekre:

  • Ha a fürtcsomópontok cpu- vagy memóriakihasználtsága meghaladja a küszöbértéket
  • Ha egy vezérlőn belüli tároló processzor- vagy memóriakihasználtsága meghaladja a küszöbértéket a megfelelő erőforráson beállított korláthoz képest
  • NotReady állapotcsomópontok száma
  • Failed, Pending, Unknown, Runningvagy Succeeded podfázisok száma
  • Ha a fürtcsomópontok szabad lemezterülete meghaladja a küszöbértéket

Ha riasztást szeretne készíteni a magas processzor- vagy memóriahasználatról, illetve a fürtcsomópontok alacsony szabad lemezterületéről, a megadott lekérdezésekkel hozzon létre metrikariasztást vagy metrikamérési riasztást. A metrikaalapú riasztások kisebb késéssel rendelkeznek, mint a naplókeresési riasztások, de a naplókeresési riasztások speciális lekérdezést és kifinomultabb eljárást biztosítanak. A naplókeresési riasztási lekérdezések az operátor használatával now összehasonlítják a dátumidőt a jelenhez, és egy órával későbbre mennek vissza. (A Container Insights az összes dátumot koordinált univerzális idő [UTC] formátumban tárolja.)

Fontos

A cikkben szereplő lekérdezések a Container Insights által gyűjtött és egy Log Analytics-munkaterületen tárolt adatoktól függenek. Ha módosította az alapértelmezett adatgyűjtési beállításokat, előfordulhat, hogy a lekérdezések nem a várt eredményeket adják vissza. Különösen, ha letiltotta a teljesítményadatok gyűjtését, mivel engedélyezte a Prometheus-metrikákat a fürthöz, a Perf táblát használó lekérdezések nem adnak vissza eredményeket.

Lásd: Adatgyűjtés konfigurálása a Container Insightsban adatgyűjtési szabály használatával előre beállított konfigurációkhoz, beleértve a teljesítményadatok gyűjtésének letiltását. További adatgyűjtési lehetőségekért tekintse meg az adatgyűjtés konfigurálása a Container Insightsban a ConfigMap használatával című témakört.

Ha nem ismeri az Azure Monitor-riasztásokat, a kezdés előtt tekintse meg a Microsoft Azure riasztásainak áttekintését. A napló lekérdezéseket használó riasztásokról további információt az Azure Monitor naplókeresési riasztásai című témakörben talál. A metrikariasztásokról további információt az Azure Monitor metrikariasztásai című témakörben talál.

Lekérdezésmérések naplózása

A naplókeresési riasztások két különböző dolgot mérhetnek, amelyek különböző forgatókönyvek virtuális gépeinek monitorozására használhatók:

  • Eredményszám: Megszámlálja a lekérdezés által visszaadott sorok számát, és használható olyan események kezelésére, mint a Windows-eseménynaplók, a Syslog és az alkalmazás kivételei.
  • Érték kiszámítása: Numerikus oszlop alapján végez számítást, és tetszőleges számú erőforrás belefoglalására használható. Ilyen például a processzorhasználat százalékos aránya.

Célerőforrások és dimenziók

Egy szabály használatával dimenziókkal figyelheti több példány értékeit. Például dimenziókat használna, ha a webhelyet vagy alkalmazást futtató több példány processzorhasználatát szeretné figyelni, és több mint 80%-os processzorhasználatra vonatkozó riasztást hozna létre.

Ha erőforrás-központú riasztásokat szeretne létrehozni nagy méretekben egy előfizetéshez vagy erőforráscsoporthoz, dimenziók szerint oszthatja fel. Ha ugyanazt a feltételt több Azure-erőforráson szeretné monitorozni, a dimenziók szerinti felosztás a riasztásokat külön riasztásokra osztja fel az egyedi kombinációk numerikus vagy sztringoszlopok használatával történő csoportosításával. Az Azure-erőforrás-azonosító oszlop felosztásával a megadott erőforrás a riasztási célhelyre kerül.

Dönthet úgy is, hogy nem osztja fel a elemet, ha több erőforrásra vonatkozó feltételt szeretne a hatókörben. Előfordulhat például, hogy riasztást szeretne létrehozni, ha az erőforráscsoport hatókörében legalább öt gép processzorhasználata meghaladja a 80%-ot.

Képernyőkép egy új naplókeresési riasztási szabályról dimenziók szerinti felosztással.

Előfordulhat, hogy látni szeretné az érintett számítógép riasztásainak listáját. Ezt a nézetet egyéni erőforrás-diagramot használó egyéni munkafüzetet használhat. A következő lekérdezés használatával jeleníthet meg riasztásokat, és használhatja az Azure Resource Graph adatforrást a munkafüzetben.

Naplókeresési riasztási szabály létrehozása

Ha naplókeresési riasztási szabályt szeretne létrehozni a portál használatával, tekintse meg ezt a példát egy naplókeresési riasztásra, amely teljes körű útmutatót nyújt. Ugyanezekkel a folyamatokkal riasztási szabályokat hozhat létre az AKS-fürtökhöz a cikkben szereplő lekérdezésekhez hasonló lekérdezésekkel.

Ha Azure Resource Manager-sablonnal (ARM) szeretne lekérdezési riasztási szabályt létrehozni, tekintse meg a Resource Manager-sablonmintákat a naplókeresési riasztási szabályokhoz az Azure Monitorban. Ugyanezekkel a folyamatokkal hozhat létre ARM-sablonokat a jelen cikkben szereplő napló lekérdezésekhez.

Erőforrás-kihasználtság

Átlagos CPU-kihasználtság a tagcsomópontok percenkénti cpu-kihasználtságának átlagaként (metrikamérés):

let endDateTime = now();
let startDateTime = ago(1h);
let trendBinSize = 1m;
let capacityCounterName = 'cpuCapacityNanoCores';
let usageCounterName = 'cpuUsageNanoCores';
KubeNodeInventory
| where TimeGenerated < endDateTime
| where TimeGenerated >= startDateTime
// cluster filter would go here if multiple clusters are reporting to the same Log Analytics workspace
| distinct ClusterName, Computer
| join hint.strategy=shuffle (
  Perf
  | where TimeGenerated < endDateTime
  | where TimeGenerated >= startDateTime
  | where ObjectName == 'K8SNode'
  | where CounterName == capacityCounterName
  | summarize LimitValue = max(CounterValue) by Computer, CounterName, bin(TimeGenerated, trendBinSize)
  | project Computer, CapacityStartTime = TimeGenerated, CapacityEndTime = TimeGenerated + trendBinSize, LimitValue
) on Computer
| join kind=inner hint.strategy=shuffle (
  Perf
  | where TimeGenerated < endDateTime + trendBinSize
  | where TimeGenerated >= startDateTime - trendBinSize
  | where ObjectName == 'K8SNode'
  | where CounterName == usageCounterName
  | project Computer, UsageValue = CounterValue, TimeGenerated
) on Computer
| where TimeGenerated >= CapacityStartTime and TimeGenerated < CapacityEndTime
| project ClusterName, Computer, TimeGenerated, UsagePercent = UsageValue * 100.0 / LimitValue
| summarize AggValue = avg(UsagePercent) by bin(TimeGenerated, trendBinSize), ClusterName

Átlagos memóriakihasználtság a tagcsomópontok percenkénti memóriakihasználtságának átlagaként (metrikamérés):

let endDateTime = now();
let startDateTime = ago(1h);
let trendBinSize = 1m;
let capacityCounterName = 'memoryCapacityBytes';
let usageCounterName = 'memoryRssBytes';
KubeNodeInventory
| where TimeGenerated < endDateTime
| where TimeGenerated >= startDateTime
// cluster filter would go here if multiple clusters are reporting to the same Log Analytics workspace
| distinct ClusterName, Computer
| join hint.strategy=shuffle (
  Perf
  | where TimeGenerated < endDateTime
  | where TimeGenerated >= startDateTime
  | where ObjectName == 'K8SNode'
  | where CounterName == capacityCounterName
  | summarize LimitValue = max(CounterValue) by Computer, CounterName, bin(TimeGenerated, trendBinSize)
  | project Computer, CapacityStartTime = TimeGenerated, CapacityEndTime = TimeGenerated + trendBinSize, LimitValue
) on Computer
| join kind=inner hint.strategy=shuffle (
  Perf
  | where TimeGenerated < endDateTime + trendBinSize
  | where TimeGenerated >= startDateTime - trendBinSize
  | where ObjectName == 'K8SNode'
  | where CounterName == usageCounterName
  | project Computer, UsageValue = CounterValue, TimeGenerated
) on Computer
| where TimeGenerated >= CapacityStartTime and TimeGenerated < CapacityEndTime
| project ClusterName, Computer, TimeGenerated, UsagePercent = UsageValue * 100.0 / LimitValue
| summarize AggValue = avg(UsagePercent) by bin(TimeGenerated, trendBinSize), ClusterName

Fontos

Az alábbi lekérdezések a fürt és a vezérlő nevének><> helyőrző értékeit <használják. A riasztások beállításakor cserélje le őket a környezetére jellemző értékekre.

Egy vezérlő összes tárolójának átlagos CPU-kihasználtsága egy vezérlő minden tárolópéldányának percenkénti cpu-kihasználtságának átlagaként (metrikamérés):

let endDateTime = now();
let startDateTime = ago(1h);
let trendBinSize = 1m;
let capacityCounterName = 'cpuLimitNanoCores';
let usageCounterName = 'cpuUsageNanoCores';
let clusterName = '<your-cluster-name>';
let controllerName = '<your-controller-name>';
KubePodInventory
| where TimeGenerated < endDateTime
| where TimeGenerated >= startDateTime
| where ClusterName == clusterName
| where ControllerName == controllerName
| extend InstanceName = strcat(ClusterId, '/', ContainerName),
         ContainerName = strcat(controllerName, '/', tostring(split(ContainerName, '/')[1]))
| distinct Computer, InstanceName, ContainerName
| join hint.strategy=shuffle (
    Perf
    | where TimeGenerated < endDateTime
    | where TimeGenerated >= startDateTime
    | where ObjectName == 'K8SContainer'
    | where CounterName == capacityCounterName
    | summarize LimitValue = max(CounterValue) by Computer, InstanceName, bin(TimeGenerated, trendBinSize)
    | project Computer, InstanceName, LimitStartTime = TimeGenerated, LimitEndTime = TimeGenerated + trendBinSize, LimitValue
) on Computer, InstanceName
| join kind=inner hint.strategy=shuffle (
    Perf
    | where TimeGenerated < endDateTime + trendBinSize
    | where TimeGenerated >= startDateTime - trendBinSize
    | where ObjectName == 'K8SContainer'
    | where CounterName == usageCounterName
    | project Computer, InstanceName, UsageValue = CounterValue, TimeGenerated
) on Computer, InstanceName
| where TimeGenerated >= LimitStartTime and TimeGenerated < LimitEndTime
| project Computer, ContainerName, TimeGenerated, UsagePercent = UsageValue * 100.0 / LimitValue
| summarize AggValue = avg(UsagePercent) by bin(TimeGenerated, trendBinSize) , ContainerName

Egy vezérlő összes tárolójának átlagos memóriakihasználtsága egy vezérlő minden tárolópéldányának percenkénti memóriakihasználtságaként (metrikamérés):

let endDateTime = now();
let startDateTime = ago(1h);
let trendBinSize = 1m;
let capacityCounterName = 'memoryLimitBytes';
let usageCounterName = 'memoryRssBytes';
let clusterName = '<your-cluster-name>';
let controllerName = '<your-controller-name>';
KubePodInventory
| where TimeGenerated < endDateTime
| where TimeGenerated >= startDateTime
| where ClusterName == clusterName
| where ControllerName == controllerName
| extend InstanceName = strcat(ClusterId, '/', ContainerName),
         ContainerName = strcat(controllerName, '/', tostring(split(ContainerName, '/')[1]))
| distinct Computer, InstanceName, ContainerName
| join hint.strategy=shuffle (
    Perf
    | where TimeGenerated < endDateTime
    | where TimeGenerated >= startDateTime
    | where ObjectName == 'K8SContainer'
    | where CounterName == capacityCounterName
    | summarize LimitValue = max(CounterValue) by Computer, InstanceName, bin(TimeGenerated, trendBinSize)
    | project Computer, InstanceName, LimitStartTime = TimeGenerated, LimitEndTime = TimeGenerated + trendBinSize, LimitValue
) on Computer, InstanceName
| join kind=inner hint.strategy=shuffle (
    Perf
    | where TimeGenerated < endDateTime + trendBinSize
    | where TimeGenerated >= startDateTime - trendBinSize
    | where ObjectName == 'K8SContainer'
    | where CounterName == usageCounterName
    | project Computer, InstanceName, UsageValue = CounterValue, TimeGenerated
) on Computer, InstanceName
| where TimeGenerated >= LimitStartTime and TimeGenerated < LimitEndTime
| project Computer, ContainerName, TimeGenerated, UsagePercent = UsageValue * 100.0 / LimitValue
| summarize AggValue = avg(UsagePercent) by bin(TimeGenerated, trendBinSize) , ContainerName

Erőforrás elérhetősége

A Ready és NotReady állapotú csomópontok és számok (metrikamérés):

let endDateTime = now();
let startDateTime = ago(1h);
let trendBinSize = 1m;
let clusterName = '<your-cluster-name>';
KubeNodeInventory
| where TimeGenerated < endDateTime
| where TimeGenerated >= startDateTime
| distinct ClusterName, Computer, TimeGenerated
| summarize ClusterSnapshotCount = count() by bin(TimeGenerated, trendBinSize), ClusterName, Computer
| join hint.strategy=broadcast kind=inner (
    KubeNodeInventory
    | where TimeGenerated < endDateTime
    | where TimeGenerated >= startDateTime
    | summarize TotalCount = count(), ReadyCount = sumif(1, Status contains ('Ready'))
                by ClusterName, Computer,  bin(TimeGenerated, trendBinSize)
    | extend NotReadyCount = TotalCount - ReadyCount
) on ClusterName, Computer, TimeGenerated
| project   TimeGenerated,
            ClusterName,
            Computer,
            ReadyCount = todouble(ReadyCount) / ClusterSnapshotCount,
            NotReadyCount = todouble(NotReadyCount) / ClusterSnapshotCount
| order by ClusterName asc, Computer asc, TimeGenerated desc

Az alábbi lekérdezés a podfázisok számát adja vissza az összes fázis alapján: Failed, , Pending, RunningUnknownvagy Succeeded.

let endDateTime = now(); 
let startDateTime = ago(1h);
let trendBinSize = 1m;
let clusterName = '<your-cluster-name>';
KubePodInventory
    | where TimeGenerated < endDateTime
    | where TimeGenerated >= startDateTime
    | where ClusterName == clusterName
    | distinct ClusterName, TimeGenerated
    | summarize ClusterSnapshotCount = count() by bin(TimeGenerated, trendBinSize), ClusterName
    | join hint.strategy=broadcast (
        KubePodInventory
        | where TimeGenerated < endDateTime
        | where TimeGenerated >= startDateTime
        | summarize PodStatus=any(PodStatus) by TimeGenerated, PodUid, ClusterName
        | summarize TotalCount = count(),
                    PendingCount = sumif(1, PodStatus =~ 'Pending'),
                    RunningCount = sumif(1, PodStatus =~ 'Running'),
                    SucceededCount = sumif(1, PodStatus =~ 'Succeeded'),
                    FailedCount = sumif(1, PodStatus =~ 'Failed')
                by ClusterName, bin(TimeGenerated, trendBinSize)
    ) on ClusterName, TimeGenerated
    | extend UnknownCount = TotalCount - PendingCount - RunningCount - SucceededCount - FailedCount
    | project TimeGenerated,
              TotalCount = todouble(TotalCount) / ClusterSnapshotCount,
              PendingCount = todouble(PendingCount) / ClusterSnapshotCount,
              RunningCount = todouble(RunningCount) / ClusterSnapshotCount,
              SucceededCount = todouble(SucceededCount) / ClusterSnapshotCount,
              FailedCount = todouble(FailedCount) / ClusterSnapshotCount,
              UnknownCount = todouble(UnknownCount) / ClusterSnapshotCount
| summarize AggValue = avg(PendingCount) by bin(TimeGenerated, trendBinSize)

Feljegyzés

Riasztás egyes podfázisok esetén, például PendingFailedUnknowna lekérdezés utolsó sorának módosításához. Például a riasztáshoz használja a következőtFailedCount| summarize AggValue = avg(FailedCount) by bin(TimeGenerated, trendBinSize): .

Az alábbi lekérdezés olyan fürtcsomópontok lemezeit adja vissza, amelyek túllépik a 90%-os szabad területet. A fürtazonosító lekéréséhez először futtassa a következő lekérdezést, és másolja ki az értéket a ClusterId tulajdonságból:

InsightsMetrics
| extend Tags = todynamic(Tags)            
| project ClusterId = Tags['container.azm.ms/clusterId']   
| distinct tostring(ClusterId)   

let clusterId = '<cluster-id>';
let endDateTime = now();
let startDateTime = ago(1h);
let trendBinSize = 1m;
InsightsMetrics
| where TimeGenerated < endDateTime
| where TimeGenerated >= startDateTime
| where Origin == 'container.azm.ms/telegraf'            
| where Namespace == 'container.azm.ms/disk'            
| extend Tags = todynamic(Tags)            
| project TimeGenerated, ClusterId = Tags['container.azm.ms/clusterId'], Computer = tostring(Tags.hostName), Device = tostring(Tags.device), Path = tostring(Tags.path), DiskMetricName = Name, DiskMetricValue = Val   
| where ClusterId =~ clusterId       
| where DiskMetricName == 'used_percent'
| summarize AggValue = max(DiskMetricValue) by bin(TimeGenerated, trendBinSize)
| where AggValue >= 90

Az egyes tárolók újraindulása (az eredmények száma) riasztás, ha az egyes rendszertároló-újraindítások száma meghaladja az elmúlt 10 perc küszöbértékét:

let _threshold = 10m; 
let _alertThreshold = 2;
let Timenow = (datetime(now) - _threshold); 
let starttime = ago(5m); 
KubePodInventory
| where TimeGenerated >= starttime
| where Namespace in ('default', 'kube-system') // the namespace filter goes here
| where ContainerRestartCount > _alertThreshold
| extend Tags = todynamic(ContainerLastStatus)
| extend startedAt = todynamic(Tags.startedAt)
| where startedAt >= Timenow
| summarize arg_max(TimeGenerated, *) by Name

Következő lépések

  • A napló lekérdezési példáiban előre definiált lekérdezéseket és példákat tekinthet meg, amelyekkel kiértékelheti vagy testre szabhatja a fürtök riasztását, vizualizációját vagy elemzését.
  • Az Azure Monitorról és a Kubernetes-fürt egyéb aspektusainak monitorozásáról további információt a Kubernetes-fürt teljesítményének megtekintése és a Kubernetes-fürt állapotának megtekintése című témakörben talál.