Analysera användning på en Log Analytics-arbetsyta

Azure Monitor-kostnaderna kan variera avsevärt beroende på mängden data som samlas in på Din Log Analytics-arbetsyta. Den här volymen påverkas av den uppsättning lösningar som använder arbetsytan och mängden data som varje lösning samlar in. Den här artikeln innehåller vägledning om hur du analyserar dina insamlade data för att styra dina datainmatningskostnader. Det hjälper dig att fastställa orsaken till högre användning än förväntat. Det hjälper dig också att förutsäga dina kostnader när du övervakar fler resurser och konfigurerar olika Azure Monitor-funktioner.

Orsaker till högre användning än förväntat

Varje Log Analytics-arbetsyta debiteras som en separat tjänst och bidrar till fakturan för din Azure-prenumeration. Mängden datainmatning kan vara betydande, beroende på följande:

• Uppsättning insikter och tjänster aktiverade och deras konfiguration.
  • Antal och typ av övervakade resurser.
  • Mängden data som samlas in från varje övervakad resurs.

En oväntad ökning av någon av dessa faktorer kan leda till ökade avgifter för datakvarhållning. Resten av den här artikeln innehåller metoder för att identifiera en sådan situation och sedan analysera insamlade data för att identifiera och minimera källan till den ökade användningen.

Skicka avisering när datainsamlingen är hög

För att undvika oväntade fakturor bör du meddelas proaktivt när du upplever överdriven användning. Med meddelandet kan du åtgärda eventuella avvikelser före faktureringsperiodens slut.

Följande exempel är en varningsregel för loggsökning som skickar en avisering om den fakturerbara datavolymen som matats in under de senaste 24 timmarna var större än 50 GB. Ändra inställningen Aviseringslogik för att använda ett annat tröskelvärde baserat på förväntad användning i din miljö. Du kan också öka frekvensen för att kontrollera användningen flera gånger varje dag, men det här alternativet resulterar i en högre avgift för aviseringsregeln.

Användningsanalys i Azure Monitor

Starta analysen med befintliga verktyg i Azure Monitor. Dessa verktyg kräver ingen konfiguration och kan ofta ge den information du behöver med minimal ansträngning. Om du behöver djupare analys av dina insamlade data än befintliga Azure Monitor-funktioner använder du någon av följande loggfrågor i Log Analytics.

Insikter om Log Analytics-arbetsyta

Log Analytics Workspace Insights ger dig en snabb förståelse av data på din arbetsyta. Du kan till exempel fastställa följande:

• Datatabeller som matar in mest datavolym i huvudtabellen.
• De viktigaste resurserna som bidrar med data.
• Trend för datainmatning.

Se fliken Användning för en uppdelning av inmatning efter lösning och tabell. Den här informationen kan hjälpa dig att snabbt identifiera de tabeller som bidrar till huvuddelen av din datavolym. Fliken visar också trender för datainsamling över tid. Du kan avgöra om datainsamlingen ökar stadigt med tiden eller plötsligt ökar som svar på en konfigurationsändring.

Välj Ytterligare frågor för fördefinierade frågor som hjälper dig att ytterligare förstå dina datamönster.

Användning och uppskattade kostnader

Diagrammet Datainmatning per lösning på sidan Användning och uppskattade kostnader för varje arbetsyta visar den totala mängden data som skickats och hur mycket som skickas av varje lösning under de senaste 31 dagarna. Den här informationen hjälper dig att fastställa trender, till exempel om en ökning beror på den totala dataanvändningen eller användningen av en viss lösning.

Köra frågor mot datavolymer från tabellen Användning

Analysera mängden fakturerbara data som samlas in av en viss tjänst eller lösning. Dessa frågor använder tabellen Användning som samlar in användningsdata för varje tabell på arbetsytan.

Fakturerbar datavolym efter typ under den senaste månaden

Usage 
| where TimeGenerated > ago(32d)
| where StartTime >= startofday(ago(31d)) and EndTime < startofday(now())
| where IsBillable == true
| summarize BillableDataGB = sum(Quantity) / 1000. by bin(StartTime, 1d), DataType 
| render columnchart

Fakturerbar datavolym efter lösning och typ under den senaste månaden

Usage 
| where TimeGenerated > ago(32d)
| where StartTime >= startofday(ago(31d)) and EndTime < startofday(now())
| where IsBillable == true
| summarize BillableDataGB = sum(Quantity) / 1000 by Solution, DataType
| sort by Solution asc, DataType asc

Köra frågor mot datavolym från händelserna direkt

Du kan använda loggfrågor i Log Analytics om du behöver djupare analys av dina insamlade data. Varje tabell på en Log Analytics-arbetsyta har följande standardkolumner som kan hjälpa dig att analysera fakturerbara data:

• _IsBillable identifierar poster som det finns en inmatningsavgift för. Använd den här kolumnen för att filtrera bort icke-fakturerbara data.
• _BilledSize ger postens storlek i byte.

Fakturerbar datavolym för specifika händelser

Om du upptäcker att en viss datatyp samlar in överdrivna data kanske du vill analysera data i tabellen för att fastställa specifika poster som ökar. Det här exemplet filtrerar specifika händelse-ID:t i Event tabellen och ger sedan ett antal för varje ID. Du kan ändra den här frågan med hjälp av kolumnerna från andra tabeller.

Event
| where TimeGenerated > startofday(ago(31d)) and TimeGenerated < startofday(now()) 
| where EventID == 5145 or EventID == 5156
| where _IsBillable == true
| summarize count(), Bytes=sum(_BilledSize) by EventID, bin(TimeGenerated, 1d)

Datavolym efter Azure-resurs, resursgrupp eller prenumeration

Du kan analysera mängden fakturerbara data som samlas in från en viss resurs eller uppsättning resurser. Dessa frågor använder kolumnerna _ResourceId och _SubscriptionId för data från resurser som finns i Azure.

Fakturerbar datavolym efter resurs-ID för den senaste hela dagen

find where TimeGenerated between(startofday(ago(1d))..startofday(now())) project _ResourceId, _BilledSize, _IsBillable
| where _IsBillable == true 
| summarize BillableDataBytes = sum(_BilledSize) by _ResourceId 
| sort by BillableDataBytes nulls last

Fakturerbar datavolym per resursgrupp för den senaste hela dagen

find where TimeGenerated between(startofday(ago(1d))..startofday(now())) project _ResourceId, _BilledSize, _IsBillable
| where _IsBillable == true 
| summarize BillableDataBytes = sum(_BilledSize) by _ResourceId
| extend resourceGroup = tostring(split(_ResourceId, "/")[4] )
| summarize BillableDataBytes = sum(BillableDataBytes) by resourceGroup 
| sort by BillableDataBytes nulls last

Det kan vara bra att parsa _ResourceId:

| parse tolower(_ResourceId) with "/subscriptions/" subscriptionId "/resourcegroups/" 
    resourceGroup "/providers/" provider "/" resourceType "/" resourceName   

Fakturerbar datavolym per prenumeration för den senaste hela dagen

find where TimeGenerated between(startofday(ago(1d))..startofday(now())) project _BilledSize, _IsBillable, _SubscriptionId
| where _IsBillable == true 
| summarize BillableDataBytes = sum(_BilledSize) by _SubscriptionId 
| sort by BillableDataBytes nulls last

Datavolym per dator

Du kan analysera mängden fakturerbara data som samlas in från en virtuell dator eller en uppsättning virtuella datorer. Tabellen Användning har inte kornigheten för att visa datavolymer för specifika virtuella datorer, så dessa frågor använder sökoperatorn för att söka i alla tabeller som innehåller ett datornamn. Användningstypen utelämnas eftersom den här frågan endast är avsedd för analys av datatrender.

Fakturerbar datavolym per dator för den senaste hela dagen

find where TimeGenerated between(startofday(ago(1d))..startofday(now())) project _BilledSize, _IsBillable, Computer, Type
| where _IsBillable == true and Type != "Usage"
| extend computerName = tolower(tostring(split(Computer, '.')[0]))
| summarize BillableDataBytes = sum(_BilledSize) by  computerName 
| sort by BillableDataBytes desc nulls last

Antal fakturerbara händelser per dator för den senaste hela dagen

find where TimeGenerated between(startofday(ago(1d))..startofday(now())) project _IsBillable, Computer, Type
| where _IsBillable == true and Type != "Usage"
| extend computerName = tolower(tostring(split(Computer, '.')[0]))
| summarize eventCount = count() by computerName  
| sort by eventCount desc nulls last

Fråga efter vanliga datatyper

Om du upptäcker att du har för stora fakturerbara data för en viss datatyp kan du behöva utföra en fråga för att analysera data i tabellen. Följande frågor innehåller exempel på några vanliga datatyper:

Security-lösningen

SecurityEvent 
| summarize AggregatedValue = count() by EventID
| order by AggregatedValue desc nulls last

Log Management-lösningen

Usage 
| where Solution == "LogManagement" and iff(isnotnull(toint(IsBillable)), IsBillable == true, IsBillable == "true") == true 
| summarize AggregatedValue = count() by DataType
| order by AggregatedValue desc nulls last

Perf-datatypen

Perf 
| summarize AggregatedValue = count() by CounterPath

Perf 
| summarize AggregatedValue = count() by CounterName

Event-datatypen

Event 
| summarize AggregatedValue = count() by EventID

Event 
| summarize AggregatedValue = count() by EventLog, EventLevelName

Syslog-datatypen

Syslog 
| summarize AggregatedValue = count() by Facility, SeverityLevel

Syslog 
| summarize AggregatedValue = count() by ProcessName

Datatypen AzureDiagnostics

AzureDiagnostics 
| summarize AggregatedValue = count() by ResourceProvider, ResourceId

Application Insights-data

Det finns två metoder för att undersöka mängden data som samlas in för Application Insights, beroende på om du har ett klassiskt eller arbetsytebaserat program. Använd egenskapen _BilledSize som är tillgänglig för varje inmatad händelse för både arbetsytebaserade och klassiska resurser. Du kan också använda aggregerad information i tabellen systemEvents för klassiska resurser.

Beroendeåtgärder genererar mest datavolym under de senaste 30 dagarna (arbetsytebaserad eller klassisk)

dependencies
| where timestamp >= startofday(ago(30d))
| summarize sum(_BilledSize) by operation_Name
| render barchart  

Daglig datavolym efter typ för den här Application Insights-resursen under de senaste 7 dagarna (endast klassisk)

systemEvents
| where timestamp >= startofday(ago(7d)) and timestamp < startofday(now())
| where type == "Billing"
| extend BillingTelemetryType = tostring(dimensions["BillingTelemetryType"])
| extend BillingTelemetrySizeInBytes = todouble(measurements["BillingTelemetrySize"])
| summarize sum(BillingTelemetrySizeInBytes) by BillingTelemetryType, bin(timestamp, 1d)  

Datavolymtrender för arbetsytebaserade resurser

Om du vill titta på datavolymtrenderna för arbetsytebaserade Application Insights-resurser använder du en fråga som innehåller alla Application Insights-tabeller. Följande frågor använder tabellnamnen som är specifika för arbetsytebaserade resurser.

Daglig datavolym efter typ för alla Application Insights-resurser på en arbetsyta i 7 dagar

union AppAvailabilityResults,
      AppBrowserTimings,
      AppDependencies,
      AppExceptions,
      AppEvents,
      AppMetrics,
      AppPageViews,
      AppPerformanceCounters,
      AppRequests,
      AppSystemEvents,
      AppTraces
| where TimeGenerated >= startofday(ago(7d)) and TimeGenerated < startofday(now())
| summarize sum(_BilledSize) by _ResourceId, bin(TimeGenerated, 1d)

Om du bara vill titta på datavolymtrenderna för en enda Application Insights-resurs lägger du till följande rad tidigare summarize i föregående fråga:

| where _ResourceId contains "<myAppInsightsResourceName>"

Förstå noder som skickar data

Om du inte har överdrivna data från någon viss källa kan du ha ett överdrivet antal agenter som skickar data.

Antal agentnoder som skickar ett pulsslag varje dag under den senaste månaden

Heartbeat 
| where TimeGenerated > startofday(ago(31d))
| summarize nodes = dcount(Computer) by bin(TimeGenerated, 1d)    
| render timechart

Antal noder som skickar data under de senaste 24 timmarna

find where TimeGenerated > ago(24h) project Computer
| extend computerName = tolower(tostring(split(Computer, '.')[0]))
| where computerName != ""
| summarize nodes = dcount(computerName)

Datavolym som skickats av varje nod under de senaste 24 timmarna

find where TimeGenerated > ago(24h) project _BilledSize, Computer
| extend computerName = tolower(tostring(split(Computer, '.')[0]))
| where computerName != ""
| summarize TotalVolumeBytes=sum(_BilledSize) by computerName

Noder som faktureras av den äldre prisnivån per nod

Den äldre prisnivån per nod faktureras för noder med kornighet per timme. Den räknar inte heller noder som bara skickar en uppsättning säkerhetsdatatyper. Om du vill hämta en lista över datorer som debiteras som noder om arbetsytan finns på den äldre prisnivån Per nod letar du efter noder som skickar fakturerade datatyper eftersom vissa datatyper är kostnadsfria. I det här fallet använder du fältet längst till vänster i det fullständigt kvalificerade domännamnet.

Följande frågor returnerar antalet datorer med fakturerade data per timme. Antalet enheter på din faktura finns i enheter med nodmånader, vilket representeras av billableNodeMonthsPerDay i frågan. Om arbetsytan har lösningen Uppdateringshantering installerad lägger du till datatyperna Update och UpdateSummary i listan i where -satsen.

find where TimeGenerated >= startofday(ago(7d)) and TimeGenerated < startofday(now()) project Computer, _IsBillable, Type, TimeGenerated
| where Type !in ("SecurityAlert", "SecurityBaseline", "SecurityBaselineSummary", "SecurityDetection", "SecurityEvent", "WindowsFirewall", "MaliciousIPCommunication", "LinuxAuditLog", "SysmonEvent", "ProtectionStatus", "WindowsEvent")
| extend computerName = tolower(tostring(split(Computer, '.')[0]))
| where computerName != ""
| where _IsBillable == true
| summarize billableNodesPerHour=dcount(computerName) by bin(TimeGenerated, 1h)
| summarize billableNodesPerDay = sum(billableNodesPerHour)/24., billableNodeMonthsPerDay = sum(billableNodesPerHour)/24./31.  by day=bin(TimeGenerated, 1d)
| sort by day asc

Antal säkerhets- och automatiseringsnoder

Antal distinkta säkerhetsnoder

union
(
    Heartbeat
    | where (Solutions has 'security' or Solutions has 'antimalware' or Solutions has 'securitycenter')
    | project Computer
),
(
    ProtectionStatus
    | where Computer !in (Heartbeat | project Computer)
    | project Computer
)
| distinct Computer
| project lowComputer = tolower(Computer)
| distinct lowComputer
| count

Antal distinkta automationsnoder

 ConfigurationData 
 | where (ConfigDataType == "WindowsServices" or ConfigDataType == "Software" or ConfigDataType =="Daemons") 
 | extend lowComputer = tolower(Computer) | summarize by lowComputer 
 | join (
     Heartbeat 
       | where SCAgentChannel == "Direct"
       | extend lowComputer = tolower(Computer) | summarize by lowComputer, ComputerEnvironment
 ) on lowComputer
 | summarize count() by ComputerEnvironment | sort by ComputerEnvironment asc

Data som inkommer sent

Om du ser hög datainmatning som rapporterats med hjälp Usage av poster, men du inte ser samma resultat som summeras _BilledSize direkt på datatypen, är det möjligt att du har för sent ankommande data. Den här situationen uppstår när data matas in med gamla tidsstämplar.

En agent kan till exempel ha ett anslutningsproblem och skicka ackumulerade data när den återansluter. Eller så kan en värd ha en felaktig tid. Båda exemplen kan resultera i en uppenbar avvikelse mellan inmatade data som rapporterats av datatypen Användning och en fråga som summerar _BilledSize över rådata för en viss dag som anges av TimeGenerated, tidsstämpeln när händelsen genererades.

Om du vill diagnostisera problem med sena data använder du kolumnen _TimeReceived och kolumnen TimeGenerated . Egenskapen _TimeReceived är den tid då posten togs emot av Azure Monitor-inmatningspunkten i Azure-molnet.

Följande exempel är ett svar på stora inmatade datavolymer med W3CIISLog-data den 2 maj 2021 för att identifiera tidsstämplarna för dessa inmatade data. Instruktionen where TimeGenerated > datetime(1970-01-01) ingår för att ge ledtråden till Log Analytics-användargränssnittet för att titta över alla data.

W3CIISLog
| where TimeGenerated > datetime(1970-01-01)
| where _TimeReceived >= datetime(2021-05-02) and _TimeReceived < datetime(2021-05-03) 
| where _IsBillable == true
| summarize BillableDataMB = sum(_BilledSize)/1.E6 by bin(TimeGenerated, 1d)
| sort by TimeGenerated asc 

Nästa steg

• Se Prisinformation för Azure Monitor-loggar för information om hur avgifter beräknas för data på en Log Analytics-arbetsyta och olika konfigurationsalternativ för att minska dina avgifter.
• Se Azure Monitor-kostnader och -användning för en beskrivning av de olika typerna av Azure Monitor-avgifter och hur du analyserar dem på din Azure-faktura.
• Se Metodtips för Azure Monitor – Kostnadshantering för bästa praxis för att konfigurera och hantera Azure Monitor för att minimera dina avgifter.
• Se Datainsamlingstransformeringar i Azure Monitor (förhandsversion) för information om hur du använder transformeringar för att minska mängden data som du samlar in på en Log Analytics-arbetsyta genom att filtrera oönskade poster och kolumner.