Övervaka dina Azure resurser och program

Använd Azure Monitor för att samla in loggar, mått och aviseringar i dina JavaScript-program och de Azure tjänster som de är beroende av. Azure Monitor är den centrala plattformstjänsten som samlar in och lagrar din telemetri. Du kan instrumentera dina program med Application Insights. Du bör övervaka din värdbaserade programtjänst, de Azure tjänster som programmet integreras med och själva programkällan.

Förstå loggar, mått och aviseringar

Telemetri är de data som samlas in från dina program och tjänster för att övervaka deras hälsa, prestanda och användning. I Azure kategoriseras telemetri i loggar, mått och aviseringar.

Azure erbjuder fyra typer av telemetri:

Välj rätt telemetri för din fråga:

Kostnadsoptimering

Du kan avsevärt minska din kost för Azure Monitor genom att förstå best practices för konfigurationsalternativ och möjligheter att minska mängden data som samlas in.

Aktivera loggning och mått för alla Azure resurser

Varje tjänst i Azure har sina egna funktioner för loggning och mått. Aktivera loggning på varje Azure resurs för att säkerställa att du har den telemetri som du behöver för att övervaka hela programmet från slutpunkt till slutpunkt.

Skapa Azure Monitor resurs

Du kan skapa en Azure Monitor resurs för att samla in loggar och mått från dina Azure resurser. Den här resursen är vanligtvis en Log Analytics arbetsyta, där loggar och mått lagras.

Du kan skapa den här resursen på flera sätt:

• Azure portal: Använd Azure-portalen för att skapa en Log Analytics arbetsyta och konfigurera diagnostikinställningar för dina resurser.
• Azure CLI: Använd Azure CLI för att skapa en Log Analytics arbetsyta och konfigurera diagnostikinställningar för dina resurser.
• PowerShell: Använd PowerShell för att skapa en Log Analytics arbetsyta och konfigurera diagnostikinställningar för dina resurser.
• Bicep: Använd Bicep mallar för att definiera och distribuera dina Azure Monitor resurser deklarativt.

Skapa en Log Analytics arbetsyta med hjälp av Azure CLI

Använd Azure CLI för att skapa en Log Analytics arbetsyta, där loggar och mått lagras. Exempel:

# Variables
resourceGroup="myResourceGroup"
location="eastus"
workspaceName="myWorkspace"
webAppName="myWebApp"
diagName="${webAppName}/appServiceLogging"
SUBSCRIPTION_ID=$(az account show --query id -o tsv)

# 1) Create a Log Analytics workspace
workspaceId=$(az monitor log-analytics workspace create \
  --resource-group $resourceGroup \
  --workspace-name $workspaceName \
  --location $location \
  --query id -o tsv)

# 2) Enable diagnostic settings on your App Service
az monitor diagnostic-settings create \
  --name "$diagName" \
  --resource "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$resourceGroup/providers/Microsoft.Web/sites/$webAppName" \
  --workspace $workspaceId \
  --logs '[{"category": "Administrative", "enabled": true},{"category":"AppServiceConsoleLogs","enabled":true},{"category":"AppServiceHTTPLogs","enabled":true}]' \
  --metrics '[{"category":"AllMetrics","enabled":true}]'

Skapa en Log Analytics arbetsyta med hjälp av Bicep

Använd Bicep för att definiera och distribuera dina Azure Monitor resurser deklarativt. Det här exemplet skapar en Log Analytics arbetsyta och konfigurerar diagnostikinställningar för en App Service.

Inkludera loggning, mått och aviseringar i dina IaC-mallar med en resursreferens för Bicep diagnosticSettings. Exempel (Bicep):

param webAppName string

resource webApp 'Microsoft.Web/sites@2022-09-01' existing = {
  name: webAppName
}

resource logAnalytics 'Microsoft.OperationalInsights/workspaces@2022-10-01' = {
  name: 'myWorkspace'
  location: resourceGroup().location
}

resource diagSettings 'Microsoft.Insights/diagnosticSettings@2021-05-01-preview' = {
  name: '${webApp.name}/appServiceLogging'
  properties: {
    workspaceId: logAnalytics.id
    logs: [
      { category: 'AppServiceConsoleLogs'; enabled: true }
      { category: 'AppServiceHTTPLogs'; enabled: true }
    ]
    metrics: [
      { category: 'AllMetrics'; enabled: true }
    ]
  }
}

Skapa aviseringar för dina resurser

Du kan konfigurera aviseringar för mått i Azure-portalen eller med hjälp av Azure CLI. Aviseringar kan innehålla specifika mått, kommunikationsströmmar (till exempel e-post) och frekvens.

Använd följande exempel för att skapa måttaviseringar i portalen eller programmatiskt:

• Azure CLI: snabbkonfiguration via az monitor metrics alert
• Bicep: deklarativ IaC-definition för Microsoft.Insights/metricAlerts

Aviseringar kan ange målmått, meddelandekanaler (e-post, webhook), allvarlighetsgrad, utvärderingsfrekvens och åtgärdsgrupper.

az monitor metrics alert create \
  --name HighCpuAlert \
  --resource-group MyResourceGroup \
  --scopes /subscriptions/{sub}/resourceGroups/MyResourceGroup/providers/Microsoft.Web/sites/myApp \
  --condition "avg CpuPercentage > 70" \
  --description "Alert when CPU goes above 70%" \
  --severity 2 \
  --window-size 5m \
  --evaluation-frequency 1m \
  --action /subscriptions/{sub}/resourceGroups/MyResourceGroup/providers/microsoft.insights/actionGroups/MyActionGroup

resource cpuAlert 'Microsoft.Insights/metricAlerts@2018-03-01' = {
  name: 'highCpuAlert'
  location: resourceGroup().location
  properties: {
    description: 'Alert when CPU goes above 70%'
    severity: 2
    enabled: true
    scopes: [
      webApp.id
    ]
    evaluationFrequency: 'PT1M'
    windowSize: 'PT5M'
    criteria: {
      allOf: [
        {
          criterionType: 'StaticThresholdCriterion'
          name: 'HighCpu'
          metricName: 'CpuPercentage'
          metricNamespace: 'Microsoft.Web/sites'
          operator: 'GreaterThan'
          threshold: 70
          timeAggregation: 'Average'
        }
      ]
    }
    autoMitigate: false
    actions: [
      {
        actionGroupId: '/subscriptions/{sub}/resourceGroups/MyResourceGroup/providers/microsoft.insights/actionGroups/MyActionGroup'
      }
    ]
  }
}

Visa loggdata

Om du vill visa loggdata i Azure portalen går du till din Log Analytics arbetsyta och väljer Logs. Du kan köra KQL-frågor (Kusto Query Language) mot loggarna.

Strömloggar

Använd följande tabell för att lära dig mer om hur du strömmar loggar.

• Azure Monitor
• App Service-
• Azure-funktioner
• Azure Container Apps

Azure MCP-server

När du utvecklar lokalt kan du använda verktyget Azure MCP Servermonitor för att köra frågor mot loggar utan att lämna din IDE. När du installerar servern får du exempel på frågor från Copilot:

• Lista arbetsytor: "Visa alla Log Analytics arbetsytor i min prenumeration."
• Hitta tabeller: "Lista alla tabeller i mitt arbetsområde 'säkerhetsloggar'"
• Komplex fråga: "Visa mig cpu-användningstrenden för mina webbservrar under de senaste 24 timmarna"

Lägga till loggning i koden

För programloggning kan Application Insights tillhandahålla:

• Standardloggning i Azure-tjänsten och i källkoden, beroende på initieringen.
• Anpassad loggning från distributionspipelinen och i källkoden.

Standardkonsolloggning (stdout/stderr)

Azure webbappar och Azure Functions tillhandahåller automatiskt anpassad loggning till stdout och stderr om du använder rätt loggningsfunktioner.

• Webbappar använder console.log('your message here').
• Funktionsappar använder context.log('your message here').

Lägga till anpassad Application Insights-loggning

Du kan lägga till mer omfattande anpassad loggning med hjälp av Application Insights i Azure Monitor. Application Insights erbjuder serverscenarier (Node.js) och klient (webbläsare):

• Lägg till Application Insights SDK i källkoden.
• Logga från Node.js med hjälp av ett npm-paket.
  • Se till att konfigurera Node.js SDK med enableAutoCollectConsole: true för att samla in anpassade konsolloggar.
• Logga från klientkoden med hjälp av ett npm-paket.
• Logga in på ditt Kubernetes-kluster eller den virtuella datorn i Azure.

Aktivera SDK-pipelineloggar (@Azure/logger)

Kontrollera SDK-verbositet med hjälp AZURE_LOG_LEVEL av miljövariabeln eller @azure/logger npm-paketet:

import { setLogLevel } from "@azure/logger";
// Options: 'error', 'warning', 'info', 'verbose'
setLogLevel(process.env.AZURE_LOG_LEVEL || "info");

Konfigurera Application Insights Node.js SDK

Initiera Application Insights för Node.js SDK med sampling, beroendeinsamling och fångst av konsolloggar:

import appInsights from "applicationinsights";
appInsights
  .setup(process.env.APPLICATIONINSIGHTS_CONNECTION_STRING || "<YOUR_CONNECTION_STRING>")
  .setAutoCollectConsole(true, true)        // collect console.log
  .setAutoCollectDependencies(true)        // track outgoing requests
  .setInternalLogging(false, true)         // SDK internal logs
  .start();

// Optional: add custom properties to all telemetry
appInsights.defaultClient.commonProperties = { serviceName: "my-service" };

Lägga till korrelation och distribuerad spårning

Application Insights SDK matar automatiskt in åtgärden och korrelations-ID:t i begäranden. Så här lägger du till anpassad korrelation eller egenskaper:

appInsights.defaultClient.trackTrace({
  message: "Custom trace",
  properties: { userId: user.id }
});

Läs mer: Vägledning för distribuerad spårning

Rensa telemetri i utvecklingsskript

Se till att loggar skickas innan processen avslutas under den lokala utvecklingen:

appInsights.defaultClient.flush({
  callback: () => process.exit(0)
});

Telemetrikonfiguration på klientsidan

För klientprogram använder du @microsoft/applicationinsights-web paketet :

import { ApplicationInsights } from "@microsoft/applicationinsights-web";
const ai = new ApplicationInsights({ config: {
  connectionString: "<YOUR_CONNECTION_STRING>",
  enableAutoRouteTracking: true
}});
ai.loadAppInsights();

Relaterat innehåll

• Azure Data Explorer (Kusto) översikt
• Aktivera diagnostikloggning för appar i Azure App Service
• Läs hur du arbetar med Azure plattformsloggar
• Azure MCP Server-övervakningsverktyg