Vytváření upozornění prohledávání protokolů z Přehledů kontejnerů

  • Článek

Přehledy kontejnerů monitorují výkon úloh kontejnerů nasazených do spravovaných nebo samoobslužných clusterů Kubernetes. Pokud chcete upozorňovat na důležité věci, tento článek popisuje, jak vytvářet upozornění založená na protokolech pro následující situace s clustery Azure Kubernetes Service (AKS):

  • Když využití procesoru nebo paměti na uzlech clusteru překročí prahovou hodnotu
  • Pokud využití procesoru nebo paměti u jakéhokoli kontejneru v rámci kontroleru překročí prahovou hodnotu v porovnání s limitem nastaveným pro odpovídající prostředek.
  • NotReady počet uzlů stavu
  • Failed, , PendingUnknown, Running, nebo Succeeded počty fází podu
  • Pokud volné místo na disku na uzlech clusteru překročí prahovou hodnotu

Pokud chcete upozorňovat na vysoké využití procesoru nebo paměti nebo nízké volné místo na disku na uzlech clusteru, použijte dotazy, které jsou k dispozici, k vytvoření upozornění na metriku nebo upozornění na měření metriky. Upozornění na metriky mají nižší latenci než upozornění prohledávání protokolů, ale upozornění prohledávání protokolů poskytují pokročilé dotazování a větší sofistikovanost. Dotazy na upozornění prohledávání protokolu porovnávají datum a čas s přítomností pomocí operátora now a vrací se o jednu hodinu. (Container Insights ukládá všechna data ve formátu UTC (Coordinated Universal Time).)

Důležité

Dotazy v tomto článku závisí na datech shromážděných službou Container Insights a uložených v pracovním prostoru služby Log Analytics. Pokud jste upravili výchozí nastavení shromažďování dat, nemusí dotazy vracet očekávané výsledky. Zejména pokud jste zakázali shromažďování dat o výkonu, protože jste povolili metriky Prometheus pro cluster, nebudou všechny dotazy používající Perf tabulku vracet výsledky.

Viz Konfigurace shromažďování dat v Přehledech kontejnerů pomocí pravidla shromažďování dat pro přednastavené konfigurace, včetně zakázání shromažďování dat o výkonu. Další možnosti shromažďování dat najdete v tématu Konfigurace shromažďování dat v Nástroji Container Insights pomocí objektu ConfigMap .

Pokud nejste obeznámeni s upozorněními služby Azure Monitor, přečtěte si před zahájením přehled výstrah v Microsoft Azure . Další informace o výstrahách, které používají dotazy protokolu, najdete v tématu Upozornění prohledávání protokolů ve službě Azure Monitor. Další informace o upozorněních na metriky najdete v tématu Upozornění metrik ve službě Azure Monitor.

Měření dotazů protokolu

Upozornění prohledávání protokolů můžou měřit dvě různé věci, které se dají použít k monitorování virtuálních počítačů v různých scénářích:

  • Počet výsledků: Spočítá počet řádků vrácených dotazem a dá se použít k práci s událostmi, jako jsou protokoly událostí Systému Windows, Syslog a výjimky aplikací.
  • Výpočet hodnoty: Provede výpočet na základě číselného sloupce a dá se použít k zahrnutí libovolného počtu prostředků. Příkladem je procento procesoru.

Cílové prostředky a dimenze

Jedno pravidlo můžete použít k monitorování hodnot více instancí pomocí dimenzí. Dimenze byste například použili v případě, že chcete monitorovat využití procesoru na více instancích, na kterých běží váš web nebo aplikace, a vytvořit upozornění na využití procesoru přes 80 %.

Pokud chcete vytvořit upozornění zaměřená na prostředky ve velkém měřítku pro předplatné nebo skupinu prostředků, můžete rozdělit podle dimenzí. Pokud chcete monitorovat stejnou podmínku u více prostředků Azure, rozdělení podle dimenzí rozdělí výstrahy na samostatné výstrahy seskupením jedinečných kombinací pomocí číselných nebo řetězcových sloupců. Rozdělením sloupce ID prostředku Azure se zadaný prostředek začlení do cíle upozornění.

Můžete se také rozhodnout, že nechcete rozdělit podmínku pro více prostředků v oboru. Můžete například chtít vytvořit upozornění, pokud alespoň pět počítačů v oboru skupiny prostředků má využití procesoru nad 80 %.

Snímek obrazovky znázorňující nové pravidlo upozornění prohledávání protokolu s rozdělením podle dimenzí

Možná budete chtít zobrazit seznam výstrah ovlivněných počítačů. K poskytnutí tohoto zobrazení můžete použít vlastní sešit, který používá vlastní graf prostředků. Pomocí následujícího dotazu zobrazte výstrahy a použijte zdroj dat Azure Resource Graph v sešitu.

Vytvoření pravidla upozornění prohledávání protokolu

Pokud chcete vytvořit pravidlo upozornění prohledávání protokolu pomocí portálu, podívejte se na tento příklad upozornění prohledávání protokolu, které poskytuje úplný návod. Stejné procesy můžete použít k vytvoření pravidel upozornění pro clustery AKS pomocí dotazů podobných dotazům v tomto článku.

Pokud chcete vytvořit pravidlo upozornění dotazu pomocí šablony Azure Resource Manageru (ARM), projděte si ukázky šablon Resource Manageru pro pravidla upozornění prohledávání protokolů ve službě Azure Monitor. Stejné procesy můžete použít k vytvoření šablon ARM pro dotazy protokolu v tomto článku.

Využití zdroje

Průměrné využití procesoru jako průměr využití procesoru členských uzlů každou minutu (měření metriky):

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

Průměrné využití paměti jako průměr využití paměti členských uzlů každou minutu (měření metriky):

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

Důležité

Následující dotazy používají zástupné hodnoty <název clusteru> a <název> kontroleru k reprezentaci clusteru a kontroleru. Při nastavování upozornění je nahraďte hodnotami specifickými pro vaše prostředí.

Průměrné využití procesoru všech kontejnerů v kontroleru jako průměr využití procesoru každé instance kontejneru v kontroleru každou minutu (měření metriky):

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

Průměrné využití paměti všech kontejnerů v kontroleru jako průměr využití paměti každé instance kontejneru v kontroleru každou minutu (měření metriky):

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

Dostupnost zdroje

Uzly a počty, které mají stav Připraveno a NotReady (měření metrik):

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

Následující dotaz vrátí počty fází podů na základě všech fází: Failed, Pending, UnknownRunningnebo 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)

Poznámka:

Chcete-li upozornit na určité fáze podu, například Pending, Failednebo Unknownupravit poslední řádek dotazu. Chcete-li například upozornit , FailedCountpoužijte | summarize AggValue = avg(FailedCount) by bin(TimeGenerated, trendBinSize).

Následující dotaz vrátí disky uzlů clusteru, které překračují 90% volné místo. Pokud chcete získat ID clusteru, nejprve spusťte následující dotaz a zkopírujte hodnotu z ClusterId vlastnosti:

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

Upozornění na restartování jednotlivých kontejnerů (počet výsledků), když počet restartování jednotlivých systémových kontejnerů překročí prahovou hodnotu za posledních 10minutch

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

Další kroky

  • Prohlédněte si příklady dotazů protokolu a podívejte se na předdefinované dotazy a příklady pro vyhodnocení nebo přizpůsobení pro upozorňování, vizualizaci nebo analýzu clusterů.
  • Další informace o službě Azure Monitor a o tom, jak monitorovat další aspekty clusteru Kubernetes, najdete v tématu Zobrazení výkonu clusteru Kubernetes a zobrazení stavu clusteru Kubernetes.