Waarschuwingen voor zoeken in logboeken maken vanuit Container Insights

  • Artikel

Container Insights bewaakt de prestaties van containerworkloads die zijn geïmplementeerd in beheerde of zelfbeheerde Kubernetes-clusters. In dit artikel wordt beschreven hoe u waarschuwingen op basis van logboeken maakt voor de volgende situaties met AKS-clusters (Azure Kubernetes Service):

  • Wanneer het CPU- of geheugengebruik op clusterknooppunten een drempelwaarde overschrijdt
  • Wanneer het CPU- of geheugengebruik voor een container binnen een controller een drempelwaarde overschrijdt in vergelijking met een limiet die is ingesteld voor de bijbehorende resource
  • NotReady aantal statusknooppunten
  • Failed, , PendingUnknown, of RunningSucceeded pod-phase counts
  • Wanneer vrije schijfruimte op clusterknooppunten een drempelwaarde overschrijdt

Als u wilt waarschuwen voor een hoog CPU- of geheugengebruik of weinig vrije schijfruimte op clusterknooppunten, gebruikt u de query's die worden opgegeven om een metrische waarschuwing of een waarschuwing voor metrische metingen te maken. Metrische waarschuwingen hebben een lagere latentie dan waarschuwingen voor zoeken in logboeken, maar waarschuwingen voor zoeken in logboeken bieden geavanceerde query's en meer verfijning. Waarschuwingsquery's voor zoeken in logboeken vergelijken een datum/tijd met het huidige met behulp van de now operator en één uur teruggaan. (Container Insights slaat alle datums op in coordinated Universal Time [UTC]-indeling.)

Belangrijk

De query's in dit artikel zijn afhankelijk van gegevens die zijn verzameld door Container Insights en zijn opgeslagen in een Log Analytics-werkruimte. Als u de standaardinstellingen voor gegevensverzameling hebt gewijzigd, retourneren de query's mogelijk niet de verwachte resultaten. Met name als u het verzamelen van prestatiegegevens hebt uitgeschakeld omdat u metrische Prometheus-gegevens voor het cluster hebt ingeschakeld, worden er geen resultaten geretourneerd door query's die gebruikmaken van de Perf tabel.

Zie Gegevensverzameling configureren in Container Insights met behulp van een regel voor het verzamelen van gegevens voor vooraf ingestelde configuraties, waaronder het uitschakelen van het verzamelen van prestatiegegevens. Zie Gegevensverzameling configureren in Container Insights met behulp van ConfigMap voor verdere opties voor gegevensverzameling.

Als u niet bekend bent met Azure Monitor-waarschuwingen, raadpleegt u Overzicht van waarschuwingen in Microsoft Azure voordat u begint. Zie Waarschuwingen voor zoeken in logboeken in Azure Monitor voor meer informatie over waarschuwingen die gebruikmaken van logboekquery's. Zie Metrische waarschuwingen in Azure Monitor voor meer informatie over metrische waarschuwingen.

Metingen van logboekquery's

Waarschuwingen voor zoeken in logboeken kunnen twee verschillende dingen meten, die kunnen worden gebruikt om virtuele machines in verschillende scenario's te bewaken:

  • Aantal resultaten: telt het aantal rijen dat door de query wordt geretourneerd en kan worden gebruikt om te werken met gebeurtenissen zoals Windows-gebeurtenislogboeken, Syslog en toepassingsuitzonderingen.
  • Berekening van een waarde: Maakt een berekening op basis van een numerieke kolom en kan worden gebruikt om een willekeurig aantal resources op te nemen. Een voorbeeld is cpu-percentage.

Doelbronnen en dimensies

U kunt één regel gebruiken om de waarden van meerdere exemplaren te bewaken met behulp van dimensies. U gebruikt bijvoorbeeld dimensies als u het CPU-gebruik wilt controleren op meerdere exemplaren waarop uw website of app wordt uitgevoerd en een waarschuwing wilt maken voor het CPU-gebruik van meer dan 80%.

Als u resourcegerichte waarschuwingen op schaal wilt maken voor een abonnement of resourcegroep, kunt u splitsen op dimensies. Wanneer u dezelfde voorwaarde wilt bewaken op meerdere Azure-resources, splitst u de waarschuwingen op in afzonderlijke waarschuwingen door unieke combinaties te groeperen met behulp van numerieke kolommen of tekenreekskolommen. Als u een Azure-resource-id-kolom splitst, wordt de opgegeven resource in het waarschuwingsdoel geplaatst.

U kunt er ook voor kiezen om niet te splitsen wanneer u een voorwaarde voor meerdere resources in het bereik wilt hebben. U kunt bijvoorbeeld een waarschuwing maken als ten minste vijf computers in het bereik van de resourcegroep CPU-gebruik hebben van meer dan 80%.

Schermopname van een nieuwe waarschuwingsregel voor zoeken in logboeken met gesplitst op dimensies.

Mogelijk wilt u een lijst weergeven met de waarschuwingen van de betreffende computer. U kunt een aangepaste werkmap gebruiken die gebruikmaakt van een aangepaste resourcegrafiek om deze weergave te bieden. Gebruik de volgende query om waarschuwingen weer te geven en gebruik de Gegevensbron Azure Resource Graph in de werkmap.

Een waarschuwingsregel voor zoeken in logboeken maken

Als u een waarschuwingsregel voor zoeken in logboeken wilt maken met behulp van de portal, raadpleegt u dit voorbeeld van een waarschuwing voor zoeken in logboeken, die een volledig overzicht biedt. U kunt dezelfde processen gebruiken om waarschuwingsregels voor AKS-clusters te maken met behulp van query's die vergelijkbaar zijn met die in dit artikel.

Als u een querywaarschuwingsregel wilt maken met behulp van een ARM-sjabloon (Azure Resource Manager), raadpleegt u Resource Manager-sjabloonvoorbeelden voor waarschuwingsregels voor zoeken in logboeken in Azure Monitor. U kunt dezelfde processen gebruiken om ARM-sjablonen te maken voor de logboekquery's in dit artikel.

Bestede uren van resource

Gemiddeld CPU-gebruik als een gemiddelde van het CPU-gebruik van lidknooppunten elke minuut (metrische meting):

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

Gemiddeld geheugengebruik als een gemiddelde van het geheugengebruik van lidknooppunten elke minuut (metrische meting):

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

Belangrijk

De volgende query's gebruiken de tijdelijke aanduidingen voor <uw clusternaam> en <uw controllernaam> om uw cluster en controller weer te geven. Vervang deze door waarden die specifiek zijn voor uw omgeving wanneer u waarschuwingen instelt.

Gemiddeld CPU-gebruik van alle containers in een controller als gemiddeld CPU-gebruik van elke containerinstantie in een controller elke minuut (metrische meting):

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

Gemiddeld geheugengebruik van alle containers in een controller als gemiddeld geheugengebruik van elke containerinstantie in een controller elke minuut (metrische meting):

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

Resourcebeschikbaarheid

Knooppunten en tellingen met de status Gereed en NotReady (metrische meting):

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

De volgende query retourneert het aantal podfasen op basis van alle fasen: Failed, Pending, Unknown, Runningof 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)

Notitie

Als u een waarschuwing wilt ontvangen voor bepaalde podfasen, zoals Pending, Failedof Unknown, wijzigt u de laatste regel van de query. Als u bijvoorbeeld wilt waarschuwen FailedCount, gebruikt u | summarize AggValue = avg(FailedCount) by bin(TimeGenerated, trendBinSize).

De volgende query retourneert clusterknooppuntschijven die meer dan 90% vrije ruimte gebruiken. Als u de cluster-id wilt ophalen, voert u eerst de volgende query uit en kopieert u de waarde uit de ClusterId eigenschap:

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

Waarschuwing voor het opnieuw opstarten van afzonderlijke containers (aantal resultaten) wanneer het aantal afzonderlijke systeemcontainers opnieuw opstarten een drempelwaarde overschrijdt voor de afgelopen 10 minuten:

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

Volgende stappen

  • Bekijk voorbeelden van logboekquery's om vooraf gedefinieerde query's en voorbeelden te bekijken die u kunt evalueren of aanpassen voor waarschuwingen, visualisaties of analyse van uw clusters.
  • Voor meer informatie over Azure Monitor en het bewaken van andere aspecten van uw Kubernetes-cluster raadpleegt u De prestaties van kubernetes-clusters weergeven en de status van het Kubernetes-cluster weergeven.