Create or update an metric alert definition.
PUT https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Insights/metricAlerts/{ruleName}?api-version=2018-03-01
Expand table
Name
In
Required
Type
Description
resourceGroupName
path
True
string
The name of the resource group. The name is case insensitive.
ruleName
path
True
string
The name of the rule.
subscriptionId
path
True
string
The ID of the target subscription.
api-version
query
True
string
The API version to use for this operation.
Expand table
Name
Required
Type
Description
location
True
string
Resource location
properties.criteria
True
MetricAlertCriteria:
defines the specific alert criteria information.
properties.enabled
True
boolean
the flag that indicates whether the metric alert is enabled.
properties.evaluationFrequency
True
string
how often the metric alert is evaluated represented in ISO 8601 duration format.
properties.scopes
True
string[]
the list of resource id's that this metric alert is scoped to. You cannot change the scope of a metric rule based on logs.
properties.severity
True
integer
Alert severity {0, 1, 2, 3, 4}
properties.windowSize
True
string
the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold.
properties.actions
MetricAlertAction []
the array of actions that are performed when the alert rule becomes active, and when an alert condition is resolved.
properties.autoMitigate
boolean
the flag that indicates whether the alert should be auto resolved or not. The default is true.
properties.description
string
the description of the metric alert that will be included in the alert email.
properties.targetResourceRegion
string
the region of the target resource(s) on which the alert is created/updated. Mandatory if the scope contains a subscription, resource group, or more than one resource.
properties.targetResourceType
string
the resource type of the target resource(s) on which the alert is created/updated. Mandatory if the scope contains a subscription, resource group, or more than one resource.
tags
object
Resource tags
Expand table
Azure Active Directory OAuth2 Flow
Type:
oauth2
Flow:
implicit
Authorization URL:
https://login.microsoftonline.com/common/oauth2/authorize
Expand table
Name
Description
user_impersonation
impersonate your user account
Expand table
Create or update a dynamic alert rule for Multiple Resources
Sample request
PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Insights/metricAlerts/MetricAlertOnMultipleResources?api-version=2018-03-01
{
"location" : "global",
"tags" : {},
"properties" : {
"description" : "This is the description of the rule1",
"severity" : 3,
"enabled" : true,
"scopes" : [
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1",
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2"
],
"evaluationFrequency" : "PT1M",
"windowSize" : "PT15M",
"targetResourceType" : "Microsoft.Compute/virtualMachines",
"targetResourceRegion" : "southcentralus",
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria",
"allOf" : [
{
"criterionType" : "DynamicThresholdCriterion",
"name" : "High_CPU_80",
"metricName" : "Percentage CPU",
"metricNamespace" : "microsoft.compute/virtualmachines",
"operator" : "GreaterOrLessThan",
"timeAggregation" : "Average",
"dimensions" : [],
"alertSensitivity" : "Medium",
"failingPeriods" : {
"numberOfEvaluationPeriods" : 4,
"minFailingPeriodsToAlert" : 4
}
}
]
},
"autoMitigate" : true,
"actions" : [
{
"actionGroupId" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2",
"webHookProperties" : {
"key11" : "value11",
"key12" : "value12"
}
}
]
}
}
import com.azure.resourcemanager.monitor.fluent.models.MetricAlertResourceInner;
import com.azure.resourcemanager.monitor.models.AggregationTypeEnum;
import com.azure.resourcemanager.monitor.models.DynamicMetricCriteria;
import com.azure.resourcemanager.monitor.models.DynamicThresholdFailingPeriods;
import com.azure.resourcemanager.monitor.models.DynamicThresholdOperator;
import com.azure.resourcemanager.monitor.models.DynamicThresholdSensitivity;
import com.azure.resourcemanager.monitor.models.MetricAlertAction;
import com.azure.resourcemanager.monitor.models.MetricAlertMultipleResourceMultipleMetricCriteria;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public final class Main {
public static void
createOrUpdateADynamicAlertRuleForMultipleResources (com.azure.resourcemanager.AzureResourceManager azure) {
azure.diagnosticSettings().manager().serviceClient().getMetricAlerts().createOrUpdateWithResponse("gigtest" ,
"MetricAlertOnMultipleResources" ,
new MetricAlertResourceInner().withLocation("global" ).withTags(mapOf())
.withDescription("This is the description of the rule1" ).withSeverity(3 ).withEnabled(true )
.withScopes(Arrays.asList(
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ,
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" ))
.withEvaluationFrequency(Duration.parse("PT1M" )).withWindowSize(Duration.parse("PT15M" ))
.withTargetResourceType("Microsoft.Compute/virtualMachines" ).withTargetResourceRegion("southcentralus" )
.withCriteria(new MetricAlertMultipleResourceMultipleMetricCriteria()
.withAllOf(Arrays.asList(new DynamicMetricCriteria().withName("High_CPU_80" )
.withMetricName("Percentage CPU" ).withMetricNamespace("microsoft.compute/virtualmachines" )
.withTimeAggregation(AggregationTypeEnum.AVERAGE).withDimensions(Arrays.asList())
.withOperator(DynamicThresholdOperator.GREATER_OR_LESS_THAN)
.withAlertSensitivity(DynamicThresholdSensitivity.MEDIUM)
.withFailingPeriods(new DynamicThresholdFailingPeriods()
.withNumberOfEvaluationPeriods(4f ).withMinFailingPeriodsToAlert(4f )))))
.withAutoMitigate(true )
.withActions(Arrays.asList(new MetricAlertAction().withActionGroupId(
"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" )
.withWebhookProperties(mapOf("key11" , "fakeTokenPlaceholder" , "key12" , "fakeTokenPlaceholder" )))),
com.azure.core.util.Context.NONE);
}
@SuppressWarnings ("unchecked" )
private static <T> Map<String, T> mapOf (Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0 ; i < inputs.length; i += 2 ) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1 ];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-monitor
# USAGE
python create_or_update_dynamic_metric_alert_multiple_resource.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main () :
client = MonitorManagementClient(
credential=DefaultAzureCredential(),
subscription_id="00000000-0000-0000-0000-000000000000" ,
)
response = client.metric_alerts.create_or_update(
resource_group_name="gigtest" ,
rule_name="MetricAlertOnMultipleResources" ,
parameters={
"location" : "global" ,
"properties" : {
"actions" : [
{
"actionGroupId" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {"key11" : "value11" , "key12" : "value12" },
}
],
"autoMitigate" : True ,
"criteria" : {
"allOf" : [
{
"alertSensitivity" : "Medium" ,
"criterionType" : "DynamicThresholdCriterion" ,
"dimensions" : [],
"failingPeriods" : {"minFailingPeriodsToAlert" : 4 , "numberOfEvaluationPeriods" : 4 },
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"name" : "High_CPU_80" ,
"operator" : "GreaterOrLessThan" ,
"timeAggregation" : "Average" ,
}
],
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
"description" : "This is the description of the rule1" ,
"enabled" : True ,
"evaluationFrequency" : "PT1M" ,
"scopes" : [
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ,
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" ,
],
"severity" : 3 ,
"targetResourceRegion" : "southcentralus" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"windowSize" : "PT15M" ,
},
"tags" : {},
},
)
print(response)
if __name__ == "__main__" :
main()
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
package armmonitor_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)
func ExampleMetricAlertsClient_CreateOrUpdate_createOrUpdateADynamicAlertRuleForMultipleResources () {
cred, err := azidentity.NewDefaultAzureCredential(nil )
if err != nil {
log.Fatalf("failed to obtain a credential: %v" , err)
}
ctx := context.Background()
clientFactory, err := armmonitor.NewClientFactory("<subscription-id>" , cred, nil )
if err != nil {
log.Fatalf("failed to create client: %v" , err)
}
res, err := clientFactory.NewMetricAlertsClient().CreateOrUpdate(ctx, "gigtest" , "MetricAlertOnMultipleResources" , armmonitor.MetricAlertResource{
Location: to.Ptr("global" ),
Tags: map [string ]*string {},
Properties: &armmonitor.MetricAlertProperties{
Description: to.Ptr("This is the description of the rule1" ),
Actions: []*armmonitor.MetricAlertAction{
{
ActionGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties: map [string ]*string {
"key11" : to.Ptr("value11" ),
"key12" : to.Ptr("value12" ),
},
}},
AutoMitigate: to.Ptr(true ),
Criteria: &armmonitor.MetricAlertMultipleResourceMultipleMetricCriteria{
ODataType: to.Ptr(armmonitor.OdatatypeMicrosoftAzureMonitorMultipleResourceMultipleMetricCriteria),
AllOf: []armmonitor.MultiMetricCriteriaClassification{
&armmonitor.DynamicMetricCriteria{
Name: to.Ptr("High_CPU_80" ),
CriterionType: to.Ptr(armmonitor.CriterionTypeDynamicThresholdCriterion),
Dimensions: []*armmonitor.MetricDimension{},
MetricName: to.Ptr("Percentage CPU" ),
MetricNamespace: to.Ptr("microsoft.compute/virtualmachines" ),
TimeAggregation: to.Ptr(armmonitor.AggregationTypeEnumAverage),
AlertSensitivity: to.Ptr(armmonitor.DynamicThresholdSensitivityMedium),
FailingPeriods: &armmonitor.DynamicThresholdFailingPeriods{
MinFailingPeriodsToAlert: to.Ptr[float32 ](4 ),
NumberOfEvaluationPeriods: to.Ptr[float32 ](4 ),
},
Operator: to.Ptr(armmonitor.DynamicThresholdOperatorGreaterOrLessThan),
}},
},
Enabled: to.Ptr(true ),
EvaluationFrequency: to.Ptr("PT1M" ),
Scopes: []*string {
to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ),
to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" )},
Severity: to.Ptr[int32 ](3 ),
TargetResourceRegion: to.Ptr("southcentralus" ),
TargetResourceType: to.Ptr("Microsoft.Compute/virtualMachines" ),
WindowSize: to.Ptr("PT15M" ),
},
}, nil )
if err != nil {
log.Fatalf("failed to finish the request: %v" , err)
}
_ = res
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
const { MonitorClient } = require ("@azure/arm-monitor" );
const { DefaultAzureCredential } = require ("@azure/identity" );
async function createOrUpdateADynamicAlertRuleForMultipleResources ( ) {
const subscriptionId =
process.env["MONITOR_SUBSCRIPTION_ID" ] || "00000000-0000-0000-0000-000000000000" ;
const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP" ] || "gigtest" ;
const ruleName = "MetricAlertOnMultipleResources" ;
const parameters = {
description : "This is the description of the rule1" ,
actions : [
{
actionGroupId :
"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
webHookProperties : { key11 : "value11" , key12 : "value12" },
},
],
autoMitigate : true ,
criteria : {
allOf : [
{
name : "High_CPU_80" ,
alertSensitivity : "Medium" ,
criterionType : "DynamicThresholdCriterion" ,
dimensions : [],
failingPeriods : {
minFailingPeriodsToAlert : 4 ,
numberOfEvaluationPeriods : 4 ,
},
metricName : "Percentage CPU" ,
metricNamespace : "microsoft.compute/virtualmachines" ,
operator : "GreaterOrLessThan" ,
timeAggregation : "Average" ,
},
],
odataType : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
enabled : true ,
evaluationFrequency : "PT1M" ,
location : "global" ,
scopes : [
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ,
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" ,
],
severity : 3 ,
tags : {},
targetResourceRegion : "southcentralus" ,
targetResourceType : "Microsoft.Compute/virtualMachines" ,
windowSize : "PT15M" ,
};
const credential = new DefaultAzureCredential();
const client = new MonitorClient(credential, subscriptionId);
const result = await client.metricAlerts.createOrUpdate(resourceGroupName, ruleName, parameters);
console .log(result);
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Monitor;
TokenCredential cred = new DefaultAzureCredential();
ArmClient client = new ArmClient(cred);
string subscriptionId = "00000000-0000-0000-0000-000000000000" ;
string resourceGroupName = "gigtest" ;
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
MetricAlertCollection collection = resourceGroupResource.GetMetricAlerts();
string ruleName = "MetricAlertOnMultipleResources" ;
MetricAlertData data = new MetricAlertData(
new AzureLocation("global" ),
3 ,
true ,
new string [] { "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" , "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" },
XmlConvert.ToTimeSpan("PT1M" ),
XmlConvert.ToTimeSpan("PT15M" ),
new MetricAlertMultipleResourceMultipleMetricCriteria
{
AllOf = {new DynamicMetricCriteria(
"High_CPU_80" ,
"Percentage CPU" ,
MetricCriteriaTimeAggregationType.Average,
DynamicThresholdOperator.GreaterOrLessThan,
DynamicThresholdSensitivity.Medium,
new DynamicThresholdFailingPeriods(4 , 4 ))
{
MetricNamespace = "microsoft.compute/virtualmachines" ,
Dimensions = {},
}},
})
{
Description = "This is the description of the rule1" ,
TargetResourceType = new ResourceType("Microsoft.Compute/virtualMachines" ),
TargetResourceRegion = new AzureLocation("southcentralus" ),
IsAutoMitigateEnabled = true ,
Actions = {new MetricAlertAction
{
ActionGroupId = new ResourceIdentifier("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties =
{
["key11" ] = "value11" ,
["key12" ] = "value12"
},
}},
Tags = { },
};
ArmOperation<MetricAlertResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, ruleName, data);
MetricAlertResource result = lro.Value;
MetricAlertData resourceData = result.Data;
Console.WriteLine($"Succeeded on id: {resourceData.Id} " );
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/providers/microsoft.insights/metricalerts/MetricAlertOnMultipleResources" ,
"type" : "Microsoft.Insights/metricAlerts" ,
"location" : "global" ,
"tags" : {
"hidden-link:/subscriptions/b67f7fec-69fc-4974-9099-a26bd6ffeda3/resourceGroups/Rac46PostSwapRG/providers/Microsoft.Web/sites/leoalerttest" : "Resource"
},
"properties" : {
"description" : "This is the description of the rule1" ,
"severity" : 3 ,
"enabled" : true ,
"scopes" : [
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ,
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2"
],
"evaluationFrequency" : "PT1M" ,
"windowSize" : "PT15M" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"targetResourceRegion" : "southcentralus" ,
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
"allOf" : [
{
"criterionType" : "DynamicThresholdCriterion" ,
"name" : "High_CPU_80" ,
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"operator" : "GreaterOrLessThan" ,
"timeAggregation" : "Average" ,
"dimensions" : [],
"alertSensitivity" : "Medium" ,
"failingPeriods" : {
"numberOfEvaluationPeriods" : 4 ,
"minFailingPeriodsToAlert" : 4
}
}
]
},
"autoMitigate" : true ,
"actions" : [
{
"actionGroupId" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {
"key11" : "value11" ,
"key12" : "value12"
}
}
]
}
}
Create or update a dynamic alert rule for Single Resource
Sample request
PUT https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Insights/metricAlerts/chiricutin?api-version=2018-03-01
{
"location" : "global",
"tags" : {},
"properties" : {
"description" : "This is the description of the rule1",
"severity" : 3,
"enabled" : true,
"scopes" : [
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme"
],
"evaluationFrequency" : "PT1M",
"windowSize" : "PT15M",
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria",
"allOf" : [
{
"criterionType" : "DynamicThresholdCriterion",
"name" : "High_CPU_80",
"metricName" : "Percentage CPU",
"metricNamespace" : "microsoft.compute/virtualmachines",
"operator" : "GreaterOrLessThan",
"timeAggregation" : "Average",
"dimensions" : [],
"alertSensitivity" : "Medium",
"failingPeriods" : {
"numberOfEvaluationPeriods" : 4,
"minFailingPeriodsToAlert" : 4
},
"ignoreDataBefore" : "2019-04-04T21:00:00.000Z"
}
]
},
"autoMitigate" : true,
"actions" : [
{
"actionGroupId" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2",
"webHookProperties" : {
"key11" : "value11",
"key12" : "value12"
}
}
]
}
}
import com.azure.resourcemanager.monitor.fluent.models.MetricAlertResourceInner;
import com.azure.resourcemanager.monitor.models.AggregationTypeEnum;
import com.azure.resourcemanager.monitor.models.DynamicMetricCriteria;
import com.azure.resourcemanager.monitor.models.DynamicThresholdFailingPeriods;
import com.azure.resourcemanager.monitor.models.DynamicThresholdOperator;
import com.azure.resourcemanager.monitor.models.DynamicThresholdSensitivity;
import com.azure.resourcemanager.monitor.models.MetricAlertAction;
import com.azure.resourcemanager.monitor.models.MetricAlertMultipleResourceMultipleMetricCriteria;
import java.time.Duration;
import java.time.OffsetDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public final class Main {
public static void
createOrUpdateADynamicAlertRuleForSingleResource (com.azure.resourcemanager.AzureResourceManager azure) {
azure.diagnosticSettings().manager().serviceClient().getMetricAlerts().createOrUpdateWithResponse("gigtest" ,
"chiricutin" ,
new MetricAlertResourceInner().withLocation("global" ).withTags(mapOf())
.withDescription("This is the description of the rule1" ).withSeverity(3 ).withEnabled(true )
.withScopes(Arrays.asList(
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme" ))
.withEvaluationFrequency(Duration.parse("PT1M" )).withWindowSize(Duration.parse("PT15M" ))
.withCriteria(new MetricAlertMultipleResourceMultipleMetricCriteria()
.withAllOf(Arrays.asList(new DynamicMetricCriteria().withName("High_CPU_80" )
.withMetricName("Percentage CPU" ).withMetricNamespace("microsoft.compute/virtualmachines" )
.withTimeAggregation(AggregationTypeEnum.AVERAGE).withDimensions(Arrays.asList())
.withOperator(DynamicThresholdOperator.GREATER_OR_LESS_THAN)
.withAlertSensitivity(DynamicThresholdSensitivity.MEDIUM)
.withFailingPeriods(new DynamicThresholdFailingPeriods().withNumberOfEvaluationPeriods(4f )
.withMinFailingPeriodsToAlert(4f ))
.withIgnoreDataBefore(OffsetDateTime.parse("2019-04-04T21:00:00.000Z" )))))
.withAutoMitigate(true )
.withActions(Arrays.asList(new MetricAlertAction().withActionGroupId(
"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" )
.withWebhookProperties(mapOf("key11" , "fakeTokenPlaceholder" , "key12" , "fakeTokenPlaceholder" )))),
com.azure.core.util.Context.NONE);
}
@SuppressWarnings ("unchecked" )
private static <T> Map<String, T> mapOf (Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0 ; i < inputs.length; i += 2 ) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1 ];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-monitor
# USAGE
python create_or_update_dynamic_metric_alert_single_resource.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main () :
client = MonitorManagementClient(
credential=DefaultAzureCredential(),
subscription_id="00000000-0000-0000-0000-000000000000" ,
)
response = client.metric_alerts.create_or_update(
resource_group_name="gigtest" ,
rule_name="chiricutin" ,
parameters={
"location" : "global" ,
"properties" : {
"actions" : [
{
"actionGroupId" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {"key11" : "value11" , "key12" : "value12" },
}
],
"autoMitigate" : True ,
"criteria" : {
"allOf" : [
{
"alertSensitivity" : "Medium" ,
"criterionType" : "DynamicThresholdCriterion" ,
"dimensions" : [],
"failingPeriods" : {"minFailingPeriodsToAlert" : 4 , "numberOfEvaluationPeriods" : 4 },
"ignoreDataBefore" : "2019-04-04T21:00:00.000Z" ,
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"name" : "High_CPU_80" ,
"operator" : "GreaterOrLessThan" ,
"timeAggregation" : "Average" ,
}
],
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
"description" : "This is the description of the rule1" ,
"enabled" : True ,
"evaluationFrequency" : "PT1M" ,
"scopes" : [
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme"
],
"severity" : 3 ,
"windowSize" : "PT15M" ,
},
"tags" : {},
},
)
print(response)
if __name__ == "__main__" :
main()
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
package armmonitor_test
import (
"context"
"log"
"time"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)
func ExampleMetricAlertsClient_CreateOrUpdate_createOrUpdateADynamicAlertRuleForSingleResource () {
cred, err := azidentity.NewDefaultAzureCredential(nil )
if err != nil {
log.Fatalf("failed to obtain a credential: %v" , err)
}
ctx := context.Background()
clientFactory, err := armmonitor.NewClientFactory("<subscription-id>" , cred, nil )
if err != nil {
log.Fatalf("failed to create client: %v" , err)
}
res, err := clientFactory.NewMetricAlertsClient().CreateOrUpdate(ctx, "gigtest" , "chiricutin" , armmonitor.MetricAlertResource{
Location: to.Ptr("global" ),
Tags: map [string ]*string {},
Properties: &armmonitor.MetricAlertProperties{
Description: to.Ptr("This is the description of the rule1" ),
Actions: []*armmonitor.MetricAlertAction{
{
ActionGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties: map [string ]*string {
"key11" : to.Ptr("value11" ),
"key12" : to.Ptr("value12" ),
},
}},
AutoMitigate: to.Ptr(true ),
Criteria: &armmonitor.MetricAlertMultipleResourceMultipleMetricCriteria{
ODataType: to.Ptr(armmonitor.OdatatypeMicrosoftAzureMonitorMultipleResourceMultipleMetricCriteria),
AllOf: []armmonitor.MultiMetricCriteriaClassification{
&armmonitor.DynamicMetricCriteria{
Name: to.Ptr("High_CPU_80" ),
CriterionType: to.Ptr(armmonitor.CriterionTypeDynamicThresholdCriterion),
Dimensions: []*armmonitor.MetricDimension{},
MetricName: to.Ptr("Percentage CPU" ),
MetricNamespace: to.Ptr("microsoft.compute/virtualmachines" ),
TimeAggregation: to.Ptr(armmonitor.AggregationTypeEnumAverage),
AlertSensitivity: to.Ptr(armmonitor.DynamicThresholdSensitivityMedium),
FailingPeriods: &armmonitor.DynamicThresholdFailingPeriods{
MinFailingPeriodsToAlert: to.Ptr[float32 ](4 ),
NumberOfEvaluationPeriods: to.Ptr[float32 ](4 ),
},
IgnoreDataBefore: to.Ptr(func () time .Time { t, _ := time.Parse(time.RFC3339Nano, "2019-04-04T21:00:00.000Z" ); return t }()),
Operator: to.Ptr(armmonitor.DynamicThresholdOperatorGreaterOrLessThan),
}},
},
Enabled: to.Ptr(true ),
EvaluationFrequency: to.Ptr("PT1M" ),
Scopes: []*string {
to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme" )},
Severity: to.Ptr[int32 ](3 ),
WindowSize: to.Ptr("PT15M" ),
},
}, nil )
if err != nil {
log.Fatalf("failed to finish the request: %v" , err)
}
_ = res
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
const { MonitorClient } = require ("@azure/arm-monitor" );
const { DefaultAzureCredential } = require ("@azure/identity" );
async function createOrUpdateADynamicAlertRuleForSingleResource ( ) {
const subscriptionId =
process.env["MONITOR_SUBSCRIPTION_ID" ] || "00000000-0000-0000-0000-000000000000" ;
const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP" ] || "gigtest" ;
const ruleName = "chiricutin" ;
const parameters = {
description : "This is the description of the rule1" ,
actions : [
{
actionGroupId :
"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
webHookProperties : { key11 : "value11" , key12 : "value12" },
},
],
autoMitigate : true ,
criteria : {
allOf : [
{
name : "High_CPU_80" ,
alertSensitivity : "Medium" ,
criterionType : "DynamicThresholdCriterion" ,
dimensions : [],
failingPeriods : {
minFailingPeriodsToAlert : 4 ,
numberOfEvaluationPeriods : 4 ,
},
ignoreDataBefore : new Date ("2019-04-04T21:00:00.000Z" ),
metricName : "Percentage CPU" ,
metricNamespace : "microsoft.compute/virtualmachines" ,
operator : "GreaterOrLessThan" ,
timeAggregation : "Average" ,
},
],
odataType : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
enabled : true ,
evaluationFrequency : "PT1M" ,
location : "global" ,
scopes : [
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme" ,
],
severity : 3 ,
tags : {},
windowSize : "PT15M" ,
};
const credential = new DefaultAzureCredential();
const client = new MonitorClient(credential, subscriptionId);
const result = await client.metricAlerts.createOrUpdate(resourceGroupName, ruleName, parameters);
console .log(result);
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Monitor;
TokenCredential cred = new DefaultAzureCredential();
ArmClient client = new ArmClient(cred);
string subscriptionId = "00000000-0000-0000-0000-000000000000" ;
string resourceGroupName = "gigtest" ;
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
MetricAlertCollection collection = resourceGroupResource.GetMetricAlerts();
string ruleName = "chiricutin" ;
MetricAlertData data = new MetricAlertData(
new AzureLocation("global" ),
3 ,
true ,
new string [] { "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme" },
XmlConvert.ToTimeSpan("PT1M" ),
XmlConvert.ToTimeSpan("PT15M" ),
new MetricAlertMultipleResourceMultipleMetricCriteria
{
AllOf = {new DynamicMetricCriteria(
"High_CPU_80" ,
"Percentage CPU" ,
MetricCriteriaTimeAggregationType.Average,
DynamicThresholdOperator.GreaterOrLessThan,
DynamicThresholdSensitivity.Medium,
new DynamicThresholdFailingPeriods(4 , 4 ))
{
IgnoreDataBefore = DateTimeOffset.Parse("2019-04-04T21:00:00.000Z" ),
MetricNamespace = "microsoft.compute/virtualmachines" ,
Dimensions = {},
}},
})
{
Description = "This is the description of the rule1" ,
IsAutoMitigateEnabled = true ,
Actions = {new MetricAlertAction
{
ActionGroupId = new ResourceIdentifier("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties =
{
["key11" ] = "value11" ,
["key12" ] = "value12"
},
}},
Tags = { },
};
ArmOperation<MetricAlertResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, ruleName, data);
MetricAlertResource result = lro.Value;
MetricAlertData resourceData = result.Data;
Console.WriteLine($"Succeeded on id: {resourceData.Id} " );
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/providers/microsoft.insights/metricalerts/chiricutin" ,
"type" : "Microsoft.Insights/metricAlerts" ,
"location" : "global" ,
"tags" : {
"hidden-link:/subscriptions/b67f7fec-69fc-4974-9099-a26bd6ffeda3/resourceGroups/Rac46PostSwapRG/providers/Microsoft.Web/sites/leoalerttest" : "Resource"
},
"properties" : {
"description" : "This is the description of the rule1" ,
"severity" : 3 ,
"enabled" : true ,
"scopes" : [
"/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme"
],
"evaluationFrequency" : "PT1M" ,
"windowSize" : "PT15M" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"targetResourceRegion" : "southcentralus" ,
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
"allOf" : [
{
"criterionType" : "DynamicThresholdCriterion" ,
"name" : "High_CPU_80" ,
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"operator" : "GreaterOrLessThan" ,
"timeAggregation" : "Average" ,
"dimensions" : [],
"alertSensitivity" : "Medium" ,
"failingPeriods" : {
"numberOfEvaluationPeriods" : 4 ,
"minFailingPeriodsToAlert" : 4
},
"ignoreDataBefore" : "2019-04-04T21:00:00.000Z"
}
]
},
"autoMitigate" : true ,
"actions" : [
{
"actionGroupId" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {
"key11" : "value11" ,
"key12" : "value12"
}
}
]
}
}
Create or update a web test alert rule
Sample request
PUT https://management.azure.com/subscriptions/12345678-1234-1234-1234-123456789101/resourceGroups/rg-example/providers/Microsoft.Insights/metricAlerts/webtest-name-example?api-version=2018-03-01
{
"location" : "global",
"tags" : {
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" : "Resource",
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" : "Resource"
},
"properties" : {
"description" : "Automatically created alert rule for availability test \"component-example\" a",
"enabled" : true,
"severity" : 4,
"windowSize" : "PT15M",
"evaluationFrequency" : "PT1M",
"criteria" : {
"failedLocationCount" : 2,
"webTestId" : "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example",
"componentId" : "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example",
"odata.type" : "Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria"
},
"actions" : [],
"scopes" : [
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example",
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example"
]
}
}
import com.azure.resourcemanager.monitor.fluent.models.MetricAlertResourceInner;
import com.azure.resourcemanager.monitor.models.WebtestLocationAvailabilityCriteria;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public final class Main {
public static void createOrUpdateAWebTestAlertRule (com.azure.resourcemanager.AzureResourceManager azure) {
azure.diagnosticSettings().manager().serviceClient().getMetricAlerts().createOrUpdateWithResponse("rg-example" ,
"webtest-name-example" ,
new MetricAlertResourceInner().withLocation("global" ).withTags(mapOf(
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ,
"Resource" ,
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ,
"Resource" ))
.withDescription("Automatically created alert rule for availability test \"component-example\" a" )
.withSeverity(4 ).withEnabled(true )
.withScopes(Arrays.asList(
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ,
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ))
.withEvaluationFrequency(Duration.parse("PT1M" )).withWindowSize(Duration.parse("PT15M" ))
.withCriteria(new WebtestLocationAvailabilityCriteria().withWebTestId(
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" )
.withComponentId(
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" )
.withFailedLocationCount(2f ))
.withActions(Arrays.asList()),
com.azure.core.util.Context.NONE);
}
@SuppressWarnings ("unchecked" )
private static <T> Map<String, T> mapOf (Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0 ; i < inputs.length; i += 2 ) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1 ];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-monitor
# USAGE
python create_or_update_web_test_metric_alert.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main () :
client = MonitorManagementClient(
credential=DefaultAzureCredential(),
subscription_id="12345678-1234-1234-1234-123456789101" ,
)
response = client.metric_alerts.create_or_update(
resource_group_name="rg-example" ,
rule_name="webtest-name-example" ,
parameters={
"location" : "global" ,
"properties" : {
"actions" : [],
"criteria" : {
"componentId" : "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ,
"failedLocationCount" : 2 ,
"odata.type" : "Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria" ,
"webTestId" : "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ,
},
"description" : 'Automatically created alert rule for availability test "component-example" a' ,
"enabled" : True ,
"evaluationFrequency" : "PT1M" ,
"scopes" : [
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ,
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ,
],
"severity" : 4 ,
"windowSize" : "PT15M" ,
},
"tags" : {
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" : "Resource" ,
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" : "Resource" ,
},
},
)
print(response)
if __name__ == "__main__" :
main()
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
package armmonitor_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)
func ExampleMetricAlertsClient_CreateOrUpdate_createOrUpdateAWebTestAlertRule () {
cred, err := azidentity.NewDefaultAzureCredential(nil )
if err != nil {
log.Fatalf("failed to obtain a credential: %v" , err)
}
ctx := context.Background()
clientFactory, err := armmonitor.NewClientFactory("<subscription-id>" , cred, nil )
if err != nil {
log.Fatalf("failed to create client: %v" , err)
}
res, err := clientFactory.NewMetricAlertsClient().CreateOrUpdate(ctx, "rg-example" , "webtest-name-example" , armmonitor.MetricAlertResource{
Location: to.Ptr("global" ),
Tags: map [string ]*string {
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" : to.Ptr("Resource" ),
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" : to.Ptr("Resource" ),
},
Properties: &armmonitor.MetricAlertProperties{
Description: to.Ptr("Automatically created alert rule for availability test \"component-example\" a" ),
Actions: []*armmonitor.MetricAlertAction{},
Criteria: &armmonitor.WebtestLocationAvailabilityCriteria{
ODataType: to.Ptr(armmonitor.OdatatypeMicrosoftAzureMonitorWebtestLocationAvailabilityCriteria),
ComponentID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ),
FailedLocationCount: to.Ptr[float32 ](2 ),
WebTestID: to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ),
},
Enabled: to.Ptr(true ),
EvaluationFrequency: to.Ptr("PT1M" ),
Scopes: []*string {
to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ),
to.Ptr("/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" )},
Severity: to.Ptr[int32 ](4 ),
WindowSize: to.Ptr("PT15M" ),
},
}, nil )
if err != nil {
log.Fatalf("failed to finish the request: %v" , err)
}
_ = res
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
const { MonitorClient } = require ("@azure/arm-monitor" );
const { DefaultAzureCredential } = require ("@azure/identity" );
async function createOrUpdateAWebTestAlertRule ( ) {
const subscriptionId =
process.env["MONITOR_SUBSCRIPTION_ID" ] || "12345678-1234-1234-1234-123456789101" ;
const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP" ] || "rg-example" ;
const ruleName = "webtest-name-example" ;
const parameters = {
description : 'Automatically created alert rule for availability test "component-example" a' ,
actions : [],
criteria : {
componentId :
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ,
failedLocationCount : 2 ,
odataType : "Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria" ,
webTestId :
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ,
},
enabled : true ,
evaluationFrequency : "PT1M" ,
location : "global" ,
scopes : [
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ,
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ,
],
severity : 4 ,
tags : {
"hiddenLink:/subscriptions/12345678123412341234123456789101/resourcegroups/rgExample/providers/microsoftInsights/components/webtestNameExample" :
"Resource" ,
"hiddenLink:/subscriptions/12345678123412341234123456789101/resourcegroups/rgExample/providers/microsoftInsights/webtests/componentExample" :
"Resource" ,
},
windowSize : "PT15M" ,
};
const credential = new DefaultAzureCredential();
const client = new MonitorClient(credential, subscriptionId);
const result = await client.metricAlerts.createOrUpdate(resourceGroupName, ruleName, parameters);
console .log(result);
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Monitor;
TokenCredential cred = new DefaultAzureCredential();
ArmClient client = new ArmClient(cred);
string subscriptionId = "12345678-1234-1234-1234-123456789101" ;
string resourceGroupName = "rg-example" ;
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
MetricAlertCollection collection = resourceGroupResource.GetMetricAlerts();
string ruleName = "webtest-name-example" ;
MetricAlertData data = new MetricAlertData(
new AzureLocation("global" ),
4 ,
true ,
new string [] { "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" , "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" },
XmlConvert.ToTimeSpan("PT1M" ),
XmlConvert.ToTimeSpan("PT15M" ),
new WebtestLocationAvailabilityCriteria(new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ), new ResourceIdentifier("/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ), 2 ))
{
Description = "Automatically created alert rule for availability test \"component-example\" a" ,
Actions = { },
Tags =
{
["hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/webtest-name-example" ] = "Resource" ,
["hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/component-example" ] = "Resource"
},
};
ArmOperation<MetricAlertResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, ruleName, data);
MetricAlertResource result = lro.Value;
MetricAlertData resourceData = result.Data;
Console.WriteLine($"Succeeded on id: {resourceData.Id} " );
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
Sample response
{
"location" : "global" ,
"type" : "Microsoft.Insights/metricAlerts" ,
"name" : "webtest-name-example" ,
"id" : "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/metricalerts/webtest-name-example" ,
"tags" : {
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/component-example" : "Resource" ,
"hidden-link:/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/webtest-name-example" : "Resource"
},
"properties" : {
"description" : "Automatically created alert rule for availability test \"webtest-name-example\" a" ,
"severity" : 4 ,
"enabled" : true ,
"scopes" : [
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/webtest-name-example" ,
"/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/component-example"
],
"evaluationFrequency" : "PT1M" ,
"windowSize" : "PT15M" ,
"criteria" : {
"webTestId" : "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/webtests/webtest-name-example" ,
"componentId" : "/subscriptions/12345678-1234-1234-1234-123456789101/resourcegroups/rg-example/providers/microsoft.insights/components/component-example" ,
"failedLocationCount" : 2 ,
"odata.type" : "Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria"
},
"actions" : []
}
}
Create or update an alert rule for Multiple Resource
Sample request
PUT https://management.azure.com/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Insights/metricAlerts/MetricAlertOnMultipleResources?api-version=2018-03-01
{
"location" : "global",
"tags" : {},
"properties" : {
"description" : "This is the description of the rule1",
"severity" : 3,
"enabled" : true,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1",
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2"
],
"evaluationFrequency" : "PT1M",
"windowSize" : "PT15M",
"targetResourceType" : "Microsoft.Compute/virtualMachines",
"targetResourceRegion" : "southcentralus",
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria",
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion",
"name" : "High_CPU_80",
"metricName" : "Percentage CPU",
"metricNamespace" : "microsoft.compute/virtualmachines",
"dimensions" : [],
"operator" : "GreaterThan",
"threshold" : 80.5,
"timeAggregation" : "Average"
}
]
},
"autoMitigate" : true,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2",
"webHookProperties" : {
"key11" : "value11",
"key12" : "value12"
}
}
]
}
}
import com.azure.resourcemanager.monitor.fluent.models.MetricAlertResourceInner;
import com.azure.resourcemanager.monitor.models.AggregationTypeEnum;
import com.azure.resourcemanager.monitor.models.MetricAlertAction;
import com.azure.resourcemanager.monitor.models.MetricAlertMultipleResourceMultipleMetricCriteria;
import com.azure.resourcemanager.monitor.models.MetricCriteria;
import com.azure.resourcemanager.monitor.models.Operator;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public final class Main {
public static void
createOrUpdateAnAlertRuleForMultipleResource (com.azure.resourcemanager.AzureResourceManager azure) {
azure.diagnosticSettings().manager().serviceClient().getMetricAlerts().createOrUpdateWithResponse("gigtest" ,
"MetricAlertOnMultipleResources" ,
new MetricAlertResourceInner().withLocation("global" ).withTags(mapOf())
.withDescription("This is the description of the rule1" ).withSeverity(3 ).withEnabled(true )
.withScopes(Arrays.asList(
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ,
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" ))
.withEvaluationFrequency(Duration.parse("PT1M" )).withWindowSize(Duration.parse("PT15M" ))
.withTargetResourceType("Microsoft.Compute/virtualMachines" ).withTargetResourceRegion("southcentralus" )
.withCriteria(new MetricAlertMultipleResourceMultipleMetricCriteria()
.withAllOf(Arrays.asList(new MetricCriteria().withName("High_CPU_80" )
.withMetricName("Percentage CPU" ).withMetricNamespace("microsoft.compute/virtualmachines" )
.withTimeAggregation(AggregationTypeEnum.AVERAGE).withDimensions(Arrays.asList())
.withOperator(Operator.GREATER_THAN).withThreshold(80.5 ))))
.withAutoMitigate(true )
.withActions(Arrays.asList(new MetricAlertAction().withActionGroupId(
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" )
.withWebhookProperties(mapOf("key11" , "fakeTokenPlaceholder" , "key12" , "fakeTokenPlaceholder" )))),
com.azure.core.util.Context.NONE);
}
@SuppressWarnings ("unchecked" )
private static <T> Map<String, T> mapOf (Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0 ; i < inputs.length; i += 2 ) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1 ];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-monitor
# USAGE
python create_or_update_metric_alert_multiple_resource.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main () :
client = MonitorManagementClient(
credential=DefaultAzureCredential(),
subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ,
)
response = client.metric_alerts.create_or_update(
resource_group_name="gigtest" ,
rule_name="MetricAlertOnMultipleResources" ,
parameters={
"location" : "global" ,
"properties" : {
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {"key11" : "value11" , "key12" : "value12" },
}
],
"autoMitigate" : True ,
"criteria" : {
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"dimensions" : [],
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"name" : "High_CPU_80" ,
"operator" : "GreaterThan" ,
"threshold" : 80.5 ,
"timeAggregation" : "Average" ,
}
],
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
"description" : "This is the description of the rule1" ,
"enabled" : True ,
"evaluationFrequency" : "PT1M" ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ,
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" ,
],
"severity" : 3 ,
"targetResourceRegion" : "southcentralus" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"windowSize" : "PT15M" ,
},
"tags" : {},
},
)
print(response)
if __name__ == "__main__" :
main()
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
package armmonitor_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)
func ExampleMetricAlertsClient_CreateOrUpdate_createOrUpdateAnAlertRuleForMultipleResource () {
cred, err := azidentity.NewDefaultAzureCredential(nil )
if err != nil {
log.Fatalf("failed to obtain a credential: %v" , err)
}
ctx := context.Background()
clientFactory, err := armmonitor.NewClientFactory("<subscription-id>" , cred, nil )
if err != nil {
log.Fatalf("failed to create client: %v" , err)
}
res, err := clientFactory.NewMetricAlertsClient().CreateOrUpdate(ctx, "gigtest" , "MetricAlertOnMultipleResources" , armmonitor.MetricAlertResource{
Location: to.Ptr("global" ),
Tags: map [string ]*string {},
Properties: &armmonitor.MetricAlertProperties{
Description: to.Ptr("This is the description of the rule1" ),
Actions: []*armmonitor.MetricAlertAction{
{
ActionGroupID: to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties: map [string ]*string {
"key11" : to.Ptr("value11" ),
"key12" : to.Ptr("value12" ),
},
}},
AutoMitigate: to.Ptr(true ),
Criteria: &armmonitor.MetricAlertMultipleResourceMultipleMetricCriteria{
ODataType: to.Ptr(armmonitor.OdatatypeMicrosoftAzureMonitorMultipleResourceMultipleMetricCriteria),
AllOf: []armmonitor.MultiMetricCriteriaClassification{
&armmonitor.MetricCriteria{
Name: to.Ptr("High_CPU_80" ),
CriterionType: to.Ptr(armmonitor.CriterionTypeStaticThresholdCriterion),
Dimensions: []*armmonitor.MetricDimension{},
MetricName: to.Ptr("Percentage CPU" ),
MetricNamespace: to.Ptr("microsoft.compute/virtualmachines" ),
TimeAggregation: to.Ptr(armmonitor.AggregationTypeEnumAverage),
Operator: to.Ptr(armmonitor.OperatorGreaterThan),
Threshold: to.Ptr[float64 ](80.5 ),
}},
},
Enabled: to.Ptr(true ),
EvaluationFrequency: to.Ptr("PT1M" ),
Scopes: []*string {
to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ),
to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" )},
Severity: to.Ptr[int32 ](3 ),
TargetResourceRegion: to.Ptr("southcentralus" ),
TargetResourceType: to.Ptr("Microsoft.Compute/virtualMachines" ),
WindowSize: to.Ptr("PT15M" ),
},
}, nil )
if err != nil {
log.Fatalf("failed to finish the request: %v" , err)
}
_ = res
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
const { MonitorClient } = require ("@azure/arm-monitor" );
const { DefaultAzureCredential } = require ("@azure/identity" );
async function createOrUpdateAnAlertRuleForMultipleResource ( ) {
const subscriptionId =
process.env["MONITOR_SUBSCRIPTION_ID" ] || "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP" ] || "gigtest" ;
const ruleName = "MetricAlertOnMultipleResources" ;
const parameters = {
description : "This is the description of the rule1" ,
actions : [
{
actionGroupId :
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
webHookProperties : { key11 : "value11" , key12 : "value12" },
},
],
autoMitigate : true ,
criteria : {
allOf : [
{
name : "High_CPU_80" ,
criterionType : "StaticThresholdCriterion" ,
dimensions : [],
metricName : "Percentage CPU" ,
metricNamespace : "microsoft.compute/virtualmachines" ,
operator : "GreaterThan" ,
threshold : 80.5 ,
timeAggregation : "Average" ,
},
],
odataType : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
enabled : true ,
evaluationFrequency : "PT1M" ,
location : "global" ,
scopes : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ,
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" ,
],
severity : 3 ,
tags : {},
targetResourceRegion : "southcentralus" ,
targetResourceType : "Microsoft.Compute/virtualMachines" ,
windowSize : "PT15M" ,
};
const credential = new DefaultAzureCredential();
const client = new MonitorClient(credential, subscriptionId);
const result = await client.metricAlerts.createOrUpdate(resourceGroupName, ruleName, parameters);
console .log(result);
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Monitor;
TokenCredential cred = new DefaultAzureCredential();
ArmClient client = new ArmClient(cred);
string subscriptionId = "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
string resourceGroupName = "gigtest" ;
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
MetricAlertCollection collection = resourceGroupResource.GetMetricAlerts();
string ruleName = "MetricAlertOnMultipleResources" ;
MetricAlertData data = new MetricAlertData(
new AzureLocation("global" ),
3 ,
true ,
new string [] { "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" , "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2" },
XmlConvert.ToTimeSpan("PT1M" ),
XmlConvert.ToTimeSpan("PT15M" ),
new MetricAlertMultipleResourceMultipleMetricCriteria
{
AllOf = {new MetricCriteria("High_CPU_80" , "Percentage CPU" , MetricCriteriaTimeAggregationType.Average, MetricCriteriaOperator.GreaterThan, 80.5 )
{
MetricNamespace = "microsoft.compute/virtualmachines" ,
Dimensions = {},
}},
})
{
Description = "This is the description of the rule1" ,
TargetResourceType = new ResourceType("Microsoft.Compute/virtualMachines" ),
TargetResourceRegion = new AzureLocation("southcentralus" ),
IsAutoMitigateEnabled = true ,
Actions = {new MetricAlertAction
{
ActionGroupId = new ResourceIdentifier("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties =
{
["key11" ] = "value11" ,
["key12" ] = "value12"
},
}},
Tags = { },
};
ArmOperation<MetricAlertResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, ruleName, data);
MetricAlertResource result = lro.Value;
MetricAlertData resourceData = result.Data;
Console.WriteLine($"Succeeded on id: {resourceData.Id} " );
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/providers/microsoft.insights/metricalerts/MetricAlertOnMultipleResources" ,
"type" : "Microsoft.Insights/metricAlerts" ,
"location" : "global" ,
"tags" : {
"hidden-link:/subscriptions/b67f7fec-69fc-4974-9099-a26bd6ffeda3/resourceGroups/Rac46PostSwapRG/providers/Microsoft.Web/sites/leoalerttest" : "Resource"
},
"properties" : {
"description" : "This is the description of the rule1" ,
"severity" : 3 ,
"enabled" : true ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme1" ,
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme2"
],
"evaluationFrequency" : "PT1M" ,
"windowSize" : "PT15M" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"targetResourceRegion" : "southcentralus" ,
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"name" : "High_CPU_80" ,
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"dimensions" : [],
"operator" : "GreaterThan" ,
"threshold" : 80.5 ,
"timeAggregation" : "Average"
}
]
},
"autoMitigate" : true ,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {
"key11" : "value11" ,
"key12" : "value12"
}
}
]
}
}
Create or update an alert rule for Single Resource
Sample request
PUT https://management.azure.com/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Insights/metricAlerts/chiricutin?api-version=2018-03-01
{
"location" : "global",
"tags" : {},
"properties" : {
"description" : "This is the description of the rule1",
"severity" : 3,
"enabled" : true,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme"
],
"evaluationFrequency" : "PT1M",
"windowSize" : "PT15M",
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria",
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion",
"name" : "High_CPU_80",
"metricName" : "\\Processor(_Total)\\% Processor Time",
"dimensions" : [],
"operator" : "GreaterThan",
"threshold" : 80.5,
"timeAggregation" : "Average"
}
]
},
"autoMitigate" : true,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2",
"webHookProperties" : {
"key11" : "value11",
"key12" : "value12"
}
}
]
}
}
import com.azure.resourcemanager.monitor.fluent.models.MetricAlertResourceInner;
import com.azure.resourcemanager.monitor.models.AggregationTypeEnum;
import com.azure.resourcemanager.monitor.models.MetricAlertAction;
import com.azure.resourcemanager.monitor.models.MetricAlertSingleResourceMultipleMetricCriteria;
import com.azure.resourcemanager.monitor.models.MetricCriteria;
import com.azure.resourcemanager.monitor.models.Operator;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public final class Main {
public static void
createOrUpdateAnAlertRuleForSingleResource (com.azure.resourcemanager.AzureResourceManager azure) {
azure.diagnosticSettings().manager().serviceClient().getMetricAlerts().createOrUpdateWithResponse("gigtest" ,
"chiricutin" ,
new MetricAlertResourceInner().withLocation("global" ).withTags(mapOf())
.withDescription("This is the description of the rule1" ).withSeverity(3 ).withEnabled(true )
.withScopes(Arrays.asList(
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme" ))
.withEvaluationFrequency(Duration.parse("Pt1m" )).withWindowSize(Duration.parse("Pt15m" ))
.withCriteria(new MetricAlertSingleResourceMultipleMetricCriteria().withAllOf(Arrays.asList(
new MetricCriteria().withName("High_CPU_80" ).withMetricName("\\Processor(_Total)\\% Processor Time" )
.withTimeAggregation(AggregationTypeEnum.AVERAGE).withDimensions(Arrays.asList())
.withOperator(Operator.GREATER_THAN).withThreshold(80.5 ))))
.withAutoMitigate(true )
.withActions(Arrays.asList(new MetricAlertAction().withActionGroupId(
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" )
.withWebhookProperties(mapOf("key11" , "fakeTokenPlaceholder" , "key12" , "fakeTokenPlaceholder" )))),
com.azure.core.util.Context.NONE);
}
@SuppressWarnings ("unchecked" )
private static <T> Map<String, T> mapOf (Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0 ; i < inputs.length; i += 2 ) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1 ];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-monitor
# USAGE
python create_or_update_metric_alert_single_resource.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main () :
client = MonitorManagementClient(
credential=DefaultAzureCredential(),
subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ,
)
response = client.metric_alerts.create_or_update(
resource_group_name="gigtest" ,
rule_name="chiricutin" ,
parameters={
"location" : "global" ,
"properties" : {
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {"key11" : "value11" , "key12" : "value12" },
}
],
"autoMitigate" : True ,
"criteria" : {
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"dimensions" : [],
"metricName" : "\\Processor(_Total)\\% Processor Time" ,
"name" : "High_CPU_80" ,
"operator" : "GreaterThan" ,
"threshold" : 80.5 ,
"timeAggregation" : "Average" ,
}
],
"odata.type" : "Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria" ,
},
"description" : "This is the description of the rule1" ,
"enabled" : True ,
"evaluationFrequency" : "PT1M" ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme"
],
"severity" : 3 ,
"windowSize" : "PT15M" ,
},
"tags" : {},
},
)
print(response)
if __name__ == "__main__" :
main()
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
package armmonitor_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)
func ExampleMetricAlertsClient_CreateOrUpdate_createOrUpdateAnAlertRuleForSingleResource () {
cred, err := azidentity.NewDefaultAzureCredential(nil )
if err != nil {
log.Fatalf("failed to obtain a credential: %v" , err)
}
ctx := context.Background()
clientFactory, err := armmonitor.NewClientFactory("<subscription-id>" , cred, nil )
if err != nil {
log.Fatalf("failed to create client: %v" , err)
}
res, err := clientFactory.NewMetricAlertsClient().CreateOrUpdate(ctx, "gigtest" , "chiricutin" , armmonitor.MetricAlertResource{
Location: to.Ptr("global" ),
Tags: map [string ]*string {},
Properties: &armmonitor.MetricAlertProperties{
Description: to.Ptr("This is the description of the rule1" ),
Actions: []*armmonitor.MetricAlertAction{
{
ActionGroupID: to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties: map [string ]*string {
"key11" : to.Ptr("value11" ),
"key12" : to.Ptr("value12" ),
},
}},
AutoMitigate: to.Ptr(true ),
Criteria: &armmonitor.MetricAlertSingleResourceMultipleMetricCriteria{
ODataType: to.Ptr(armmonitor.OdatatypeMicrosoftAzureMonitorSingleResourceMultipleMetricCriteria),
AllOf: []*armmonitor.MetricCriteria{
{
Name: to.Ptr("High_CPU_80" ),
CriterionType: to.Ptr(armmonitor.CriterionTypeStaticThresholdCriterion),
Dimensions: []*armmonitor.MetricDimension{},
MetricName: to.Ptr("\\Processor(_Total)\\% Processor Time" ),
TimeAggregation: to.Ptr(armmonitor.AggregationTypeEnumAverage),
Operator: to.Ptr(armmonitor.OperatorGreaterThan),
Threshold: to.Ptr[float64 ](80.5 ),
}},
},
Enabled: to.Ptr(true ),
EvaluationFrequency: to.Ptr("Pt1m" ),
Scopes: []*string {
to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme" )},
Severity: to.Ptr[int32 ](3 ),
WindowSize: to.Ptr("Pt15m" ),
},
}, nil )
if err != nil {
log.Fatalf("failed to finish the request: %v" , err)
}
_ = res
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
const { MonitorClient } = require ("@azure/arm-monitor" );
const { DefaultAzureCredential } = require ("@azure/identity" );
async function createOrUpdateAnAlertRuleForSingleResource ( ) {
const subscriptionId =
process.env["MONITOR_SUBSCRIPTION_ID" ] || "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP" ] || "gigtest" ;
const ruleName = "chiricutin" ;
const parameters = {
description : "This is the description of the rule1" ,
actions : [
{
actionGroupId :
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
webHookProperties : { key11 : "value11" , key12 : "value12" },
},
],
autoMitigate : true ,
criteria : {
allOf : [
{
name : "High_CPU_80" ,
criterionType : "StaticThresholdCriterion" ,
dimensions : [],
metricName : "\\Processor(_Total)\\% Processor Time" ,
operator : "GreaterThan" ,
threshold : 80.5 ,
timeAggregation : "Average" ,
},
],
odataType : "Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria" ,
},
enabled : true ,
evaluationFrequency : "Pt1m" ,
location : "global" ,
scopes : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme" ,
],
severity : 3 ,
tags : {},
windowSize : "Pt15m" ,
};
const credential = new DefaultAzureCredential();
const client = new MonitorClient(credential, subscriptionId);
const result = await client.metricAlerts.createOrUpdate(resourceGroupName, ruleName, parameters);
console .log(result);
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Monitor;
TokenCredential cred = new DefaultAzureCredential();
ArmClient client = new ArmClient(cred);
string subscriptionId = "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
string resourceGroupName = "gigtest" ;
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
MetricAlertCollection collection = resourceGroupResource.GetMetricAlerts();
string ruleName = "chiricutin" ;
MetricAlertData data = new MetricAlertData(
new AzureLocation("global" ),
3 ,
true ,
new string [] { "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme" },
XmlConvert.ToTimeSpan("PT1M" ),
XmlConvert.ToTimeSpan("PT15M" ),
new MetricAlertSingleResourceMultipleMetricCriteria
{
AllOf = {new MetricCriteria("High_CPU_80" , "\\Processor(_Total)\\% Processor Time" , MetricCriteriaTimeAggregationType.Average, MetricCriteriaOperator.GreaterThan, 80.5 )
{
Dimensions = {},
}},
})
{
Description = "This is the description of the rule1" ,
IsAutoMitigateEnabled = true ,
Actions = {new MetricAlertAction
{
ActionGroupId = new ResourceIdentifier("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties =
{
["key11" ] = "value11" ,
["key12" ] = "value12"
},
}},
Tags = { },
};
ArmOperation<MetricAlertResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, ruleName, data);
MetricAlertResource result = lro.Value;
MetricAlertData resourceData = result.Data;
Console.WriteLine($"Succeeded on id: {resourceData.Id} " );
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/providers/microsoft.insights/metricalerts/chiricutin" ,
"type" : "Microsoft.Insights/metricAlerts" ,
"location" : "global" ,
"tags" : {
"hidden-link:/subscriptions/b67f7fec-69fc-4974-9099-a26bd6ffeda3/resourceGroups/Rac46PostSwapRG/providers/Microsoft.Web/sites/leoalerttest" : "Resource"
},
"properties" : {
"description" : "This is the description of the rule1" ,
"severity" : 3 ,
"enabled" : true ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Compute/virtualMachines/gigwadme"
],
"evaluationFrequency" : "PT1M" ,
"windowSize" : "PT15M" ,
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria" ,
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"name" : "High_CPU_80" ,
"metricName" : "\\Processor(_Total)\\% Processor Time" ,
"dimensions" : [],
"operator" : "GreaterThan" ,
"threshold" : 80.5 ,
"timeAggregation" : "Average"
}
]
},
"autoMitigate" : true ,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {
"key11" : "value11" ,
"key12" : "value12"
}
}
]
}
}
Create or update an alert rule on Resource group(s)
Sample request
PUT https://management.azure.com/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1/providers/Microsoft.Insights/metricAlerts/MetricAlertAtResourceGroupLevel?api-version=2018-03-01
{
"location" : "global",
"tags" : {},
"properties" : {
"description" : "This is the description of the rule1",
"severity" : 3,
"enabled" : true,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1",
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest2"
],
"evaluationFrequency" : "PT1M",
"windowSize" : "PT15M",
"targetResourceType" : "Microsoft.Compute/virtualMachines",
"targetResourceRegion" : "southcentralus",
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria",
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion",
"name" : "High_CPU_80",
"metricName" : "Percentage CPU",
"metricNamespace" : "microsoft.compute/virtualmachines",
"dimensions" : [],
"operator" : "GreaterThan",
"threshold" : 80.5,
"timeAggregation" : "Average"
}
]
},
"autoMitigate" : true,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2",
"webHookProperties" : {
"key11" : "value11",
"key12" : "value12"
}
}
]
}
}
import com.azure.resourcemanager.monitor.fluent.models.MetricAlertResourceInner;
import com.azure.resourcemanager.monitor.models.AggregationTypeEnum;
import com.azure.resourcemanager.monitor.models.MetricAlertAction;
import com.azure.resourcemanager.monitor.models.MetricAlertMultipleResourceMultipleMetricCriteria;
import com.azure.resourcemanager.monitor.models.MetricCriteria;
import com.azure.resourcemanager.monitor.models.Operator;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public final class Main {
public static void createOrUpdateAnAlertRuleOnResourceGroupS (com.azure.resourcemanager.AzureResourceManager azure) {
azure.diagnosticSettings().manager().serviceClient().getMetricAlerts().createOrUpdateWithResponse("gigtest1" ,
"MetricAlertAtResourceGroupLevel" ,
new MetricAlertResourceInner().withLocation("global" ).withTags(mapOf())
.withDescription("This is the description of the rule1" ).withSeverity(3 ).withEnabled(true )
.withScopes(Arrays.asList("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1" ,
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest2" ))
.withEvaluationFrequency(Duration.parse("PT1M" )).withWindowSize(Duration.parse("PT15M" ))
.withTargetResourceType("Microsoft.Compute/virtualMachines" ).withTargetResourceRegion("southcentralus" )
.withCriteria(new MetricAlertMultipleResourceMultipleMetricCriteria()
.withAllOf(Arrays.asList(new MetricCriteria().withName("High_CPU_80" )
.withMetricName("Percentage CPU" ).withMetricNamespace("microsoft.compute/virtualmachines" )
.withTimeAggregation(AggregationTypeEnum.AVERAGE).withDimensions(Arrays.asList())
.withOperator(Operator.GREATER_THAN).withThreshold(80.5 ))))
.withAutoMitigate(true )
.withActions(Arrays.asList(new MetricAlertAction().withActionGroupId(
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" )
.withWebhookProperties(mapOf("key11" , "fakeTokenPlaceholder" , "key12" , "fakeTokenPlaceholder" )))),
com.azure.core.util.Context.NONE);
}
@SuppressWarnings ("unchecked" )
private static <T> Map<String, T> mapOf (Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0 ; i < inputs.length; i += 2 ) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1 ];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-monitor
# USAGE
python create_or_update_metric_alert_resource_group.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main () :
client = MonitorManagementClient(
credential=DefaultAzureCredential(),
subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ,
)
response = client.metric_alerts.create_or_update(
resource_group_name="gigtest1" ,
rule_name="MetricAlertAtResourceGroupLevel" ,
parameters={
"location" : "global" ,
"properties" : {
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {"key11" : "value11" , "key12" : "value12" },
}
],
"autoMitigate" : True ,
"criteria" : {
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"dimensions" : [],
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"name" : "High_CPU_80" ,
"operator" : "GreaterThan" ,
"threshold" : 80.5 ,
"timeAggregation" : "Average" ,
}
],
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
"description" : "This is the description of the rule1" ,
"enabled" : True ,
"evaluationFrequency" : "PT1M" ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1" ,
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest2" ,
],
"severity" : 3 ,
"targetResourceRegion" : "southcentralus" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"windowSize" : "PT15M" ,
},
"tags" : {},
},
)
print(response)
if __name__ == "__main__" :
main()
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
package armmonitor_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)
func ExampleMetricAlertsClient_CreateOrUpdate_createOrUpdateAnAlertRuleOnResourceGroupS () {
cred, err := azidentity.NewDefaultAzureCredential(nil )
if err != nil {
log.Fatalf("failed to obtain a credential: %v" , err)
}
ctx := context.Background()
clientFactory, err := armmonitor.NewClientFactory("<subscription-id>" , cred, nil )
if err != nil {
log.Fatalf("failed to create client: %v" , err)
}
res, err := clientFactory.NewMetricAlertsClient().CreateOrUpdate(ctx, "gigtest1" , "MetricAlertAtResourceGroupLevel" , armmonitor.MetricAlertResource{
Location: to.Ptr("global" ),
Tags: map [string ]*string {},
Properties: &armmonitor.MetricAlertProperties{
Description: to.Ptr("This is the description of the rule1" ),
Actions: []*armmonitor.MetricAlertAction{
{
ActionGroupID: to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties: map [string ]*string {
"key11" : to.Ptr("value11" ),
"key12" : to.Ptr("value12" ),
},
}},
AutoMitigate: to.Ptr(true ),
Criteria: &armmonitor.MetricAlertMultipleResourceMultipleMetricCriteria{
ODataType: to.Ptr(armmonitor.OdatatypeMicrosoftAzureMonitorMultipleResourceMultipleMetricCriteria),
AllOf: []armmonitor.MultiMetricCriteriaClassification{
&armmonitor.MetricCriteria{
Name: to.Ptr("High_CPU_80" ),
CriterionType: to.Ptr(armmonitor.CriterionTypeStaticThresholdCriterion),
Dimensions: []*armmonitor.MetricDimension{},
MetricName: to.Ptr("Percentage CPU" ),
MetricNamespace: to.Ptr("microsoft.compute/virtualmachines" ),
TimeAggregation: to.Ptr(armmonitor.AggregationTypeEnumAverage),
Operator: to.Ptr(armmonitor.OperatorGreaterThan),
Threshold: to.Ptr[float64 ](80.5 ),
}},
},
Enabled: to.Ptr(true ),
EvaluationFrequency: to.Ptr("PT1M" ),
Scopes: []*string {
to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1" ),
to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest2" )},
Severity: to.Ptr[int32 ](3 ),
TargetResourceRegion: to.Ptr("southcentralus" ),
TargetResourceType: to.Ptr("Microsoft.Compute/virtualMachines" ),
WindowSize: to.Ptr("PT15M" ),
},
}, nil )
if err != nil {
log.Fatalf("failed to finish the request: %v" , err)
}
_ = res
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
const { MonitorClient } = require ("@azure/arm-monitor" );
const { DefaultAzureCredential } = require ("@azure/identity" );
async function createOrUpdateAnAlertRuleOnResourceGroupS ( ) {
const subscriptionId =
process.env["MONITOR_SUBSCRIPTION_ID" ] || "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP" ] || "gigtest1" ;
const ruleName = "MetricAlertAtResourceGroupLevel" ;
const parameters = {
description : "This is the description of the rule1" ,
actions : [
{
actionGroupId :
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
webHookProperties : { key11 : "value11" , key12 : "value12" },
},
],
autoMitigate : true ,
criteria : {
allOf : [
{
name : "High_CPU_80" ,
criterionType : "StaticThresholdCriterion" ,
dimensions : [],
metricName : "Percentage CPU" ,
metricNamespace : "microsoft.compute/virtualmachines" ,
operator : "GreaterThan" ,
threshold : 80.5 ,
timeAggregation : "Average" ,
},
],
odataType : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
enabled : true ,
evaluationFrequency : "PT1M" ,
location : "global" ,
scopes : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1" ,
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest2" ,
],
severity : 3 ,
tags : {},
targetResourceRegion : "southcentralus" ,
targetResourceType : "Microsoft.Compute/virtualMachines" ,
windowSize : "PT15M" ,
};
const credential = new DefaultAzureCredential();
const client = new MonitorClient(credential, subscriptionId);
const result = await client.metricAlerts.createOrUpdate(resourceGroupName, ruleName, parameters);
console .log(result);
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Monitor;
TokenCredential cred = new DefaultAzureCredential();
ArmClient client = new ArmClient(cred);
string subscriptionId = "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
string resourceGroupName = "gigtest1" ;
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
MetricAlertCollection collection = resourceGroupResource.GetMetricAlerts();
string ruleName = "MetricAlertAtResourceGroupLevel" ;
MetricAlertData data = new MetricAlertData(
new AzureLocation("global" ),
3 ,
true ,
new string [] { "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1" , "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest2" },
XmlConvert.ToTimeSpan("PT1M" ),
XmlConvert.ToTimeSpan("PT15M" ),
new MetricAlertMultipleResourceMultipleMetricCriteria
{
AllOf = {new MetricCriteria("High_CPU_80" , "Percentage CPU" , MetricCriteriaTimeAggregationType.Average, MetricCriteriaOperator.GreaterThan, 80.5 )
{
MetricNamespace = "microsoft.compute/virtualmachines" ,
Dimensions = {},
}},
})
{
Description = "This is the description of the rule1" ,
TargetResourceType = new ResourceType("Microsoft.Compute/virtualMachines" ),
TargetResourceRegion = new AzureLocation("southcentralus" ),
IsAutoMitigateEnabled = true ,
Actions = {new MetricAlertAction
{
ActionGroupId = new ResourceIdentifier("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties =
{
["key11" ] = "value11" ,
["key12" ] = "value12"
},
}},
Tags = { },
};
ArmOperation<MetricAlertResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, ruleName, data);
MetricAlertResource result = lro.Value;
MetricAlertData resourceData = result.Data;
Console.WriteLine($"Succeeded on id: {resourceData.Id} " );
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1/providers/providers/microsoft.insights/metricalerts/MetricAlertAtResourceGroupLevel" ,
"type" : "Microsoft.Insights/metricAlerts" ,
"location" : "global" ,
"tags" : {
"hidden-link:/subscriptions/b67f7fec-69fc-4974-9099-a26bd6ffeda3/resourceGroups/Rac46PostSwapRG/providers/Microsoft.Web/sites/leoalerttest" : "Resource"
},
"properties" : {
"description" : "This is the description of the rule1" ,
"severity" : 3 ,
"enabled" : true ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest1" ,
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest2"
],
"evaluationFrequency" : "PT1M" ,
"windowSize" : "PT15M" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"targetResourceRegion" : "southcentralus" ,
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"name" : "High_CPU_80" ,
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"dimensions" : [],
"operator" : "GreaterThan" ,
"threshold" : 80.5 ,
"timeAggregation" : "Average"
}
]
},
"autoMitigate" : true ,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {
"key11" : "value11" ,
"key12" : "value12"
}
}
]
}
}
Create or update an alert rule on Subscription
Sample request
PUT https://management.azure.com/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Insights/metricAlerts/MetricAlertAtSubscriptionLevel?api-version=2018-03-01
{
"location" : "global",
"tags" : {},
"properties" : {
"description" : "This is the description of the rule1",
"severity" : 3,
"enabled" : true,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7"
],
"evaluationFrequency" : "PT1M",
"windowSize" : "PT15M",
"targetResourceType" : "Microsoft.Compute/virtualMachines",
"targetResourceRegion" : "southcentralus",
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria",
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion",
"name" : "High_CPU_80",
"metricName" : "Percentage CPU",
"metricNamespace" : "microsoft.compute/virtualmachines",
"dimensions" : [],
"operator" : "GreaterThan",
"threshold" : 80.5,
"timeAggregation" : "Average"
}
]
},
"autoMitigate" : true,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2",
"webHookProperties" : {
"key11" : "value11",
"key12" : "value12"
}
}
]
}
}
import com.azure.resourcemanager.monitor.fluent.models.MetricAlertResourceInner;
import com.azure.resourcemanager.monitor.models.AggregationTypeEnum;
import com.azure.resourcemanager.monitor.models.MetricAlertAction;
import com.azure.resourcemanager.monitor.models.MetricAlertMultipleResourceMultipleMetricCriteria;
import com.azure.resourcemanager.monitor.models.MetricCriteria;
import com.azure.resourcemanager.monitor.models.Operator;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public final class Main {
public static void createOrUpdateAnAlertRuleOnSubscription (com.azure.resourcemanager.AzureResourceManager azure) {
azure.diagnosticSettings().manager().serviceClient().getMetricAlerts().createOrUpdateWithResponse("gigtest" ,
"MetricAlertAtSubscriptionLevel" ,
new MetricAlertResourceInner().withLocation("global" ).withTags(mapOf())
.withDescription("This is the description of the rule1" ).withSeverity(3 ).withEnabled(true )
.withScopes(Arrays.asList("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ))
.withEvaluationFrequency(Duration.parse("PT1M" )).withWindowSize(Duration.parse("PT15M" ))
.withTargetResourceType("Microsoft.Compute/virtualMachines" ).withTargetResourceRegion("southcentralus" )
.withCriteria(new MetricAlertMultipleResourceMultipleMetricCriteria()
.withAllOf(Arrays.asList(new MetricCriteria().withName("High_CPU_80" )
.withMetricName("Percentage CPU" ).withMetricNamespace("microsoft.compute/virtualmachines" )
.withTimeAggregation(AggregationTypeEnum.AVERAGE).withDimensions(Arrays.asList())
.withOperator(Operator.GREATER_THAN).withThreshold(80.5 ))))
.withAutoMitigate(true )
.withActions(Arrays.asList(new MetricAlertAction().withActionGroupId(
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" )
.withWebhookProperties(mapOf("key11" , "fakeTokenPlaceholder" , "key12" , "fakeTokenPlaceholder" )))),
com.azure.core.util.Context.NONE);
}
@SuppressWarnings ("unchecked" )
private static <T> Map<String, T> mapOf (Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0 ; i < inputs.length; i += 2 ) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1 ];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-monitor
# USAGE
python create_or_update_metric_alert_subscription.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main () :
client = MonitorManagementClient(
credential=DefaultAzureCredential(),
subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ,
)
response = client.metric_alerts.create_or_update(
resource_group_name="gigtest" ,
rule_name="MetricAlertAtSubscriptionLevel" ,
parameters={
"location" : "global" ,
"properties" : {
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {"key11" : "value11" , "key12" : "value12" },
}
],
"autoMitigate" : True ,
"criteria" : {
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"dimensions" : [],
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"name" : "High_CPU_80" ,
"operator" : "GreaterThan" ,
"threshold" : 80.5 ,
"timeAggregation" : "Average" ,
}
],
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
"description" : "This is the description of the rule1" ,
"enabled" : True ,
"evaluationFrequency" : "PT1M" ,
"scopes" : ["/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ],
"severity" : 3 ,
"targetResourceRegion" : "southcentralus" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"windowSize" : "PT15M" ,
},
"tags" : {},
},
)
print(response)
if __name__ == "__main__" :
main()
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
package armmonitor_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)
func ExampleMetricAlertsClient_CreateOrUpdate_createOrUpdateAnAlertRuleOnSubscription () {
cred, err := azidentity.NewDefaultAzureCredential(nil )
if err != nil {
log.Fatalf("failed to obtain a credential: %v" , err)
}
ctx := context.Background()
clientFactory, err := armmonitor.NewClientFactory("<subscription-id>" , cred, nil )
if err != nil {
log.Fatalf("failed to create client: %v" , err)
}
res, err := clientFactory.NewMetricAlertsClient().CreateOrUpdate(ctx, "gigtest" , "MetricAlertAtSubscriptionLevel" , armmonitor.MetricAlertResource{
Location: to.Ptr("global" ),
Tags: map [string ]*string {},
Properties: &armmonitor.MetricAlertProperties{
Description: to.Ptr("This is the description of the rule1" ),
Actions: []*armmonitor.MetricAlertAction{
{
ActionGroupID: to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties: map [string ]*string {
"key11" : to.Ptr("value11" ),
"key12" : to.Ptr("value12" ),
},
}},
AutoMitigate: to.Ptr(true ),
Criteria: &armmonitor.MetricAlertMultipleResourceMultipleMetricCriteria{
ODataType: to.Ptr(armmonitor.OdatatypeMicrosoftAzureMonitorMultipleResourceMultipleMetricCriteria),
AllOf: []armmonitor.MultiMetricCriteriaClassification{
&armmonitor.MetricCriteria{
Name: to.Ptr("High_CPU_80" ),
CriterionType: to.Ptr(armmonitor.CriterionTypeStaticThresholdCriterion),
Dimensions: []*armmonitor.MetricDimension{},
MetricName: to.Ptr("Percentage CPU" ),
MetricNamespace: to.Ptr("microsoft.compute/virtualmachines" ),
TimeAggregation: to.Ptr(armmonitor.AggregationTypeEnumAverage),
Operator: to.Ptr(armmonitor.OperatorGreaterThan),
Threshold: to.Ptr[float64 ](80.5 ),
}},
},
Enabled: to.Ptr(true ),
EvaluationFrequency: to.Ptr("PT1M" ),
Scopes: []*string {
to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" )},
Severity: to.Ptr[int32 ](3 ),
TargetResourceRegion: to.Ptr("southcentralus" ),
TargetResourceType: to.Ptr("Microsoft.Compute/virtualMachines" ),
WindowSize: to.Ptr("PT15M" ),
},
}, nil )
if err != nil {
log.Fatalf("failed to finish the request: %v" , err)
}
_ = res
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
const { MonitorClient } = require ("@azure/arm-monitor" );
const { DefaultAzureCredential } = require ("@azure/identity" );
async function createOrUpdateAnAlertRuleOnSubscription ( ) {
const subscriptionId =
process.env["MONITOR_SUBSCRIPTION_ID" ] || "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP" ] || "gigtest" ;
const ruleName = "MetricAlertAtSubscriptionLevel" ;
const parameters = {
description : "This is the description of the rule1" ,
actions : [
{
actionGroupId :
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
webHookProperties : { key11 : "value11" , key12 : "value12" },
},
],
autoMitigate : true ,
criteria : {
allOf : [
{
name : "High_CPU_80" ,
criterionType : "StaticThresholdCriterion" ,
dimensions : [],
metricName : "Percentage CPU" ,
metricNamespace : "microsoft.compute/virtualmachines" ,
operator : "GreaterThan" ,
threshold : 80.5 ,
timeAggregation : "Average" ,
},
],
odataType : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
enabled : true ,
evaluationFrequency : "PT1M" ,
location : "global" ,
scopes : ["/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ],
severity : 3 ,
tags : {},
targetResourceRegion : "southcentralus" ,
targetResourceType : "Microsoft.Compute/virtualMachines" ,
windowSize : "PT15M" ,
};
const credential = new DefaultAzureCredential();
const client = new MonitorClient(credential, subscriptionId);
const result = await client.metricAlerts.createOrUpdate(resourceGroupName, ruleName, parameters);
console .log(result);
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Monitor;
TokenCredential cred = new DefaultAzureCredential();
ArmClient client = new ArmClient(cred);
string subscriptionId = "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
string resourceGroupName = "gigtest" ;
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
MetricAlertCollection collection = resourceGroupResource.GetMetricAlerts();
string ruleName = "MetricAlertAtSubscriptionLevel" ;
MetricAlertData data = new MetricAlertData(
new AzureLocation("global" ),
3 ,
true ,
new string [] { "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" },
XmlConvert.ToTimeSpan("PT1M" ),
XmlConvert.ToTimeSpan("PT15M" ),
new MetricAlertMultipleResourceMultipleMetricCriteria
{
AllOf = {new MetricCriteria("High_CPU_80" , "Percentage CPU" , MetricCriteriaTimeAggregationType.Average, MetricCriteriaOperator.GreaterThan, 80.5 )
{
MetricNamespace = "microsoft.compute/virtualmachines" ,
Dimensions = {},
}},
})
{
Description = "This is the description of the rule1" ,
TargetResourceType = new ResourceType("Microsoft.Compute/virtualMachines" ),
TargetResourceRegion = new AzureLocation("southcentralus" ),
IsAutoMitigateEnabled = true ,
Actions = {new MetricAlertAction
{
ActionGroupId = new ResourceIdentifier("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties =
{
["key11" ] = "value11" ,
["key12" ] = "value12"
},
}},
Tags = { },
};
ArmOperation<MetricAlertResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, ruleName, data);
MetricAlertResource result = lro.Value;
MetricAlertData resourceData = result.Data;
Console.WriteLine($"Succeeded on id: {resourceData.Id} " );
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/providers/microsoft.insights/metricalerts/MetricAlertAtSubscriptionLevel" ,
"type" : "Microsoft.Insights/metricAlerts" ,
"location" : "global" ,
"tags" : {
"hidden-link:/subscriptions/b67f7fec-69fc-4974-9099-a26bd6ffeda3/resourceGroups/Rac46PostSwapRG/providers/Microsoft.Web/sites/leoalerttest" : "Resource"
},
"properties" : {
"description" : "This is the description of the rule1" ,
"severity" : 3 ,
"enabled" : true ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7"
],
"evaluationFrequency" : "PT1M" ,
"windowSize" : "PT15M" ,
"targetResourceType" : "Microsoft.Compute/virtualMachines" ,
"targetResourceRegion" : "southcentralus" ,
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"name" : "High_CPU_80" ,
"metricName" : "Percentage CPU" ,
"metricNamespace" : "microsoft.compute/virtualmachines" ,
"dimensions" : [],
"operator" : "GreaterThan" ,
"threshold" : 80.5 ,
"timeAggregation" : "Average"
}
]
},
"autoMitigate" : true ,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {
"key11" : "value11" ,
"key12" : "value12"
}
}
]
}
}
Create or update an alert rules with dimensions
Sample request
PUT https://management.azure.com/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.Insights/metricAlerts/MetricAlertOnMultipleDimensions?api-version=2018-03-01
{
"location" : "global",
"tags" : {},
"properties" : {
"description" : "This is the description of the rule1",
"enabled" : true,
"severity" : 3,
"windowSize" : "P1D",
"evaluationFrequency" : "PT1H",
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.KeyVault/vaults/keyVaultResource"
],
"criteria" : {
"allOf" : [
{
"metricName" : "Availability",
"metricNamespace" : "Microsoft.KeyVault/vaults",
"operator" : "GreaterThan",
"timeAggregation" : "Average",
"name" : "Metric1",
"dimensions" : [
{
"name" : "ActivityName",
"operator" : "Include",
"values" : [
"*"
]
},
{
"name" : "StatusCode",
"operator" : "Include",
"values" : [
"200"
]
}
],
"criterionType" : "StaticThresholdCriterion",
"threshold" : 55
}
],
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria"
},
"actions" : [
{
"actionGroupId" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2",
"webHookProperties" : {
"key11" : "value11",
"key12" : "value12"
}
}
],
"autoMitigate" : true
}
}
import com.azure.resourcemanager.monitor.fluent.models.MetricAlertResourceInner;
import com.azure.resourcemanager.monitor.models.AggregationTypeEnum;
import com.azure.resourcemanager.monitor.models.MetricAlertAction;
import com.azure.resourcemanager.monitor.models.MetricAlertMultipleResourceMultipleMetricCriteria;
import com.azure.resourcemanager.monitor.models.MetricCriteria;
import com.azure.resourcemanager.monitor.models.MetricDimension;
import com.azure.resourcemanager.monitor.models.Operator;
import java.time.Duration;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public final class Main {
public static void createOrUpdateAnAlertRulesWithDimensions (com.azure.resourcemanager.AzureResourceManager azure) {
azure.diagnosticSettings().manager().serviceClient().getMetricAlerts().createOrUpdateWithResponse("gigtest" ,
"MetricAlertOnMultipleDimensions" ,
new MetricAlertResourceInner().withLocation("global" ).withTags(mapOf())
.withDescription("This is the description of the rule1" ).withSeverity(3 ).withEnabled(true )
.withScopes(Arrays.asList(
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.KeyVault/vaults/keyVaultResource" ))
.withEvaluationFrequency(Duration.parse("PT1H" )).withWindowSize(Duration.parse("P1D" ))
.withCriteria(new MetricAlertMultipleResourceMultipleMetricCriteria()
.withAllOf(Arrays.asList(new MetricCriteria().withName("Metric1" ).withMetricName("Availability" )
.withMetricNamespace("Microsoft.KeyVault/vaults" )
.withTimeAggregation(AggregationTypeEnum.AVERAGE)
.withDimensions(Arrays.asList(
new MetricDimension().withName("ActivityName" ).withOperator("Include" )
.withValues(Arrays.asList("*" )),
new MetricDimension().withName("StatusCode" ).withOperator("Include" )
.withValues(Arrays.asList("200" ))))
.withOperator(Operator.GREATER_THAN).withThreshold(55.0 ))))
.withAutoMitigate(true )
.withActions(Arrays.asList(new MetricAlertAction().withActionGroupId(
"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" )
.withWebhookProperties(mapOf("key11" , "fakeTokenPlaceholder" , "key12" , "fakeTokenPlaceholder" )))),
com.azure.core.util.Context.NONE);
}
@SuppressWarnings ("unchecked" )
private static <T> Map<String, T> mapOf (Object... inputs) {
Map<String, T> map = new HashMap<>();
for (int i = 0 ; i < inputs.length; i += 2 ) {
String key = (String) inputs[i];
T value = (T) inputs[i + 1 ];
map.put(key, value);
}
return map;
}
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
from azure.identity import DefaultAzureCredential
from azure.mgmt.monitor import MonitorManagementClient
"""
# PREREQUISITES
pip install azure-identity
pip install azure-mgmt-monitor
# USAGE
python create_or_update_metric_alert_with_dimensions.py
Before run the sample, please set the values of the client ID, tenant ID and client secret
of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""
def main () :
client = MonitorManagementClient(
credential=DefaultAzureCredential(),
subscription_id="14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ,
)
response = client.metric_alerts.create_or_update(
resource_group_name="gigtest" ,
rule_name="MetricAlertOnMultipleDimensions" ,
parameters={
"location" : "global" ,
"properties" : {
"actions" : [
{
"actionGroupId" : "/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {"key11" : "value11" , "key12" : "value12" },
}
],
"autoMitigate" : True ,
"criteria" : {
"allOf" : [
{
"criterionType" : "StaticThresholdCriterion" ,
"dimensions" : [
{"name" : "ActivityName" , "operator" : "Include" , "values" : ["*" ]},
{"name" : "StatusCode" , "operator" : "Include" , "values" : ["200" ]},
],
"metricName" : "Availability" ,
"metricNamespace" : "Microsoft.KeyVault/vaults" ,
"name" : "Metric1" ,
"operator" : "GreaterThan" ,
"threshold" : 55 ,
"timeAggregation" : "Average" ,
}
],
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
"description" : "This is the description of the rule1" ,
"enabled" : True ,
"evaluationFrequency" : "PT1H" ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.KeyVault/vaults/keyVaultResource"
],
"severity" : 3 ,
"windowSize" : "P1D" ,
},
"tags" : {},
},
)
print(response)
if __name__ == "__main__" :
main()
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
package armmonitor_test
import (
"context"
"log"
"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/monitor/armmonitor"
)
func ExampleMetricAlertsClient_CreateOrUpdate_createOrUpdateAnAlertRulesWithDimensions () {
cred, err := azidentity.NewDefaultAzureCredential(nil )
if err != nil {
log.Fatalf("failed to obtain a credential: %v" , err)
}
ctx := context.Background()
clientFactory, err := armmonitor.NewClientFactory("<subscription-id>" , cred, nil )
if err != nil {
log.Fatalf("failed to create client: %v" , err)
}
res, err := clientFactory.NewMetricAlertsClient().CreateOrUpdate(ctx, "gigtest" , "MetricAlertOnMultipleDimensions" , armmonitor.MetricAlertResource{
Location: to.Ptr("global" ),
Tags: map [string ]*string {},
Properties: &armmonitor.MetricAlertProperties{
Description: to.Ptr("This is the description of the rule1" ),
Actions: []*armmonitor.MetricAlertAction{
{
ActionGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties: map [string ]*string {
"key11" : to.Ptr("value11" ),
"key12" : to.Ptr("value12" ),
},
}},
AutoMitigate: to.Ptr(true ),
Criteria: &armmonitor.MetricAlertMultipleResourceMultipleMetricCriteria{
ODataType: to.Ptr(armmonitor.OdatatypeMicrosoftAzureMonitorMultipleResourceMultipleMetricCriteria),
AllOf: []armmonitor.MultiMetricCriteriaClassification{
&armmonitor.MetricCriteria{
Name: to.Ptr("Metric1" ),
CriterionType: to.Ptr(armmonitor.CriterionTypeStaticThresholdCriterion),
Dimensions: []*armmonitor.MetricDimension{
{
Name: to.Ptr("ActivityName" ),
Operator: to.Ptr("Include" ),
Values: []*string {
to.Ptr("*" )},
},
{
Name: to.Ptr("StatusCode" ),
Operator: to.Ptr("Include" ),
Values: []*string {
to.Ptr("200" )},
}},
MetricName: to.Ptr("Availability" ),
MetricNamespace: to.Ptr("Microsoft.KeyVault/vaults" ),
TimeAggregation: to.Ptr(armmonitor.AggregationTypeEnumAverage),
Operator: to.Ptr(armmonitor.OperatorGreaterThan),
Threshold: to.Ptr[float64 ](55 ),
}},
},
Enabled: to.Ptr(true ),
EvaluationFrequency: to.Ptr("PT1H" ),
Scopes: []*string {
to.Ptr("/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.KeyVault/vaults/keyVaultResource" )},
Severity: to.Ptr[int32 ](3 ),
WindowSize: to.Ptr("P1D" ),
},
}, nil )
if err != nil {
log.Fatalf("failed to finish the request: %v" , err)
}
_ = res
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
const { MonitorClient } = require ("@azure/arm-monitor" );
const { DefaultAzureCredential } = require ("@azure/identity" );
async function createOrUpdateAnAlertRulesWithDimensions ( ) {
const subscriptionId =
process.env["MONITOR_SUBSCRIPTION_ID" ] || "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
const resourceGroupName = process.env["MONITOR_RESOURCE_GROUP" ] || "gigtest" ;
const ruleName = "MetricAlertOnMultipleDimensions" ;
const parameters = {
description : "This is the description of the rule1" ,
actions : [
{
actionGroupId :
"/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
webHookProperties : { key11 : "value11" , key12 : "value12" },
},
],
autoMitigate : true ,
criteria : {
allOf : [
{
name : "Metric1" ,
criterionType : "StaticThresholdCriterion" ,
dimensions : [
{ name : "ActivityName" , operator : "Include" , values : ["*" ] },
{ name : "StatusCode" , operator : "Include" , values : ["200" ] },
],
metricName : "Availability" ,
metricNamespace : "Microsoft.KeyVault/vaults" ,
operator : "GreaterThan" ,
threshold : 55 ,
timeAggregation : "Average" ,
},
],
odataType : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
},
enabled : true ,
evaluationFrequency : "PT1H" ,
location : "global" ,
scopes : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.KeyVault/vaults/keyVaultResource" ,
],
severity : 3 ,
tags : {},
windowSize : "P1D" ,
};
const credential = new DefaultAzureCredential();
const client = new MonitorClient(credential, subscriptionId);
const result = await client.metricAlerts.createOrUpdate(resourceGroupName, ruleName, parameters);
console .log(result);
}
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
using Azure;
using Azure.ResourceManager;
using System;
using System.Threading.Tasks;
using System.Xml;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager.Monitor.Models;
using Azure.ResourceManager.Resources;
using Azure.ResourceManager.Monitor;
TokenCredential cred = new DefaultAzureCredential();
ArmClient client = new ArmClient(cred);
string subscriptionId = "14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7" ;
string resourceGroupName = "gigtest" ;
ResourceIdentifier resourceGroupResourceId = ResourceGroupResource.CreateResourceIdentifier(subscriptionId, resourceGroupName);
ResourceGroupResource resourceGroupResource = client.GetResourceGroupResource(resourceGroupResourceId);
MetricAlertCollection collection = resourceGroupResource.GetMetricAlerts();
string ruleName = "MetricAlertOnMultipleDimensions" ;
MetricAlertData data = new MetricAlertData(
new AzureLocation("global" ),
3 ,
true ,
new string [] { "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.KeyVault/vaults/keyVaultResource" },
XmlConvert.ToTimeSpan("PT1H" ),
XmlConvert.ToTimeSpan("P1D" ),
new MetricAlertMultipleResourceMultipleMetricCriteria
{
AllOf = {new MetricCriteria("Metric1" , "Availability" , MetricCriteriaTimeAggregationType.Average, MetricCriteriaOperator.GreaterThan, 55 )
{
MetricNamespace = "Microsoft.KeyVault/vaults" ,
Dimensions = {new MetricDimension("ActivityName" , "Include" , new string []{"*" }), new MetricDimension("StatusCode" , "Include" , new string []{"200" })},
}},
})
{
Description = "This is the description of the rule1" ,
IsAutoMitigateEnabled = true ,
Actions = {new MetricAlertAction
{
ActionGroupId = new ResourceIdentifier("/subscriptions/00000000-0000-0000-0000-000000000000/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ),
WebHookProperties =
{
["key11" ] = "value11" ,
["key12" ] = "value12"
},
}},
Tags = { },
};
ArmOperation<MetricAlertResource> lro = await collection.CreateOrUpdateAsync(WaitUntil.Completed, ruleName, data);
MetricAlertResource result = lro.Value;
MetricAlertData resourceData = result.Data;
Console.WriteLine($"Succeeded on id: {resourceData.Id} " );
To use the Azure SDK library in your project, see this documentation . To provide feedback on this code sample, open a GitHub issue
Sample response
{
"id" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/providers/microsoft.insights/metricalerts/MetricAlertWithDimensions" ,
"type" : "Microsoft.Insights/metricAlerts" ,
"location" : "global" ,
"tags" : {
"hidden-link:/subscriptions/b67f7fec-69fc-4974-9099-a26bd6ffeda3/resourceGroups/Rac46PostSwapRG/providers/Microsoft.Web/sites/leoalerttest" : "Resource"
},
"properties" : {
"description" : "This is the description of the rule1" ,
"severity" : 3 ,
"enabled" : true ,
"scopes" : [
"/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourceGroups/gigtest/providers/Microsoft.KeyVault/vaults/keyVaultResource"
],
"evaluationFrequency" : "PT1H" ,
"windowSize" : "P1D" ,
"targetResourceType" : "Microsoft.KeyVault/vaults" ,
"targetResourceRegion" : "southcentralus" ,
"criteria" : {
"odata.type" : "Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria" ,
"allOf" : [
{
"metricName" : "Availability" ,
"metricNamespace" : "Microsoft.KeyVault/vaults" ,
"operator" : "GreaterThan" ,
"timeAggregation" : "Average" ,
"name" : "Metric1" ,
"dimensions" : [
{
"name" : "ActivityName" ,
"operator" : "Include" ,
"values" : [
"*"
]
},
{
"name" : "StatusCode" ,
"operator" : "Include" ,
"values" : [
"200"
]
}
],
"criterionType" : "StaticThresholdCriterion" ,
"threshold" : 55
}
]
},
"autoMitigate" : true ,
"actions" : [
{
"actionGroupId" : "/subscriptions/14ddf0c5-77c5-4b53-84f6-e1fa43ad68f7/resourcegroups/gigtest/providers/microsoft.insights/actiongroups/group2" ,
"webHookProperties" : {
"key11" : "value11" ,
"key12" : "value12"
}
}
]
}
}
Expand table
Object
An array of objects with 'type' and 'info' properties. The schema of 'info' is service-specific and dependent on the 'type' string.
Expand table
Name
Type
Description
info
object
The additional information specific to the type.
type
string
The type of additional information.
Enumeration
the criteria time aggregation types.
Expand table
Value
Description
Average
Count
Maximum
Minimum
Total
Object
Criterion for dynamic threshold.
Expand table
Name
Type
Description
alertSensitivity
DynamicThresholdSensitivity
The extent of deviation required to trigger an alert. This will affect how tight the threshold is to the metric series pattern.
criterionType
string:
DynamicThresholdCriterion
Specifies the type of threshold criteria
dimensions
MetricDimension []
List of dimension conditions.
failingPeriods
DynamicThresholdFailingPeriods
The minimum number of violations required within the selected lookback time window required to raise an alert.
ignoreDataBefore
string
Use this option to set the date from which to start learning the metric historical data and calculate the dynamic thresholds (in ISO8601 format)
metricName
string
Name of the metric.
metricNamespace
string
Namespace of the metric.
name
string
Name of the criteria.
operator
DynamicThresholdOperator
The operator used to compare the metric value against the threshold.
skipMetricValidation
boolean
Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
timeAggregation
AggregationTypeEnum
the criteria time aggregation types.
DynamicThresholdFailingPeriods
Object
The minimum number of violations required within the selected lookback time window required to raise an alert.
Expand table
Name
Type
Description
minFailingPeriodsToAlert
number
The number of violations to trigger an alert. Should be smaller or equal to numberOfEvaluationPeriods.
numberOfEvaluationPeriods
number
The number of aggregated lookback points. The lookback time window is calculated based on the aggregation granularity (windowSize) and the selected number of aggregated points.
Enumeration
The operator used to compare the metric value against the threshold.
Expand table
Value
Description
GreaterOrLessThan
GreaterThan
LessThan
DynamicThresholdSensitivity
Enumeration
The extent of deviation required to trigger an alert. This will affect how tight the threshold is to the metric series pattern.
Expand table
Value
Description
High
Low
Medium
Object
Expand table
Name
Type
Description
additionalInfo
AdditionalInfo []
An array of objects with 'type' and 'info' properties. The schema of 'info' is service-specific and dependent on the 'type' string.
code
string
Unlocalized string which can be used to programmatically identify the error.
details
ErrorDetail []
An array of additional nested error response info objects, as described by this contract.
message
string
Describes the error in detail and provides debugging information. If Accept-Language is set in the request, it must be localized to that language.
target
string
The target of the particular error (for example, the name of the property in error).
Object
Describes details of an error response.
Expand table
Name
Type
Description
additionalInfo
AdditionalInfo []
An array of objects with 'type' and 'info' properties. The schema of 'info' is service-specific and dependent on the 'type' string.
code
string
Unlocalized string which can be used to programmatically identify the error.
message
string
Describes the error in detail and provides debugging information.
target
string
The target of the particular error (for example, the name of the property in error).
Object
Describes the format of Error response.
Expand table
Name
Type
Description
error
Error
Object
An alert action.
Expand table
Name
Type
Description
actionGroupId
string
the id of the action group to use.
webHookProperties
object
This field allows specifying custom properties, which would be appended to the alert payload sent as input to the webhook.
MetricAlertMultipleResourceMultipleMetricCriteria
Object
Specifies the metric alert criteria for multiple resource that has multiple metric criteria.
Expand table
Name
Type
Description
allOf
MultiMetricCriteria[]:
the list of multiple metric criteria for this 'all of' operation.
odata.type
string:
Microsoft.Azure.Monitor.MultipleResourceMultipleMetricCriteria
specifies the type of the alert criteria.
Object
The metric alert resource.
Expand table
Name
Type
Description
id
string
Azure resource Id
location
string
Resource location
name
string
Azure resource name
properties.actions
MetricAlertAction []
the array of actions that are performed when the alert rule becomes active, and when an alert condition is resolved.
properties.autoMitigate
boolean
the flag that indicates whether the alert should be auto resolved or not. The default is true.
properties.criteria
MetricAlertCriteria:
defines the specific alert criteria information.
properties.description
string
the description of the metric alert that will be included in the alert email.
properties.enabled
boolean
the flag that indicates whether the metric alert is enabled.
properties.evaluationFrequency
string
how often the metric alert is evaluated represented in ISO 8601 duration format.
properties.isMigrated
boolean
the value indicating whether this alert rule is migrated.
properties.lastUpdatedTime
string
Last time the rule was updated in ISO8601 format.
properties.scopes
string[]
the list of resource id's that this metric alert is scoped to. You cannot change the scope of a metric rule based on logs.
properties.severity
integer
Alert severity {0, 1, 2, 3, 4}
properties.targetResourceRegion
string
the region of the target resource(s) on which the alert is created/updated. Mandatory if the scope contains a subscription, resource group, or more than one resource.
properties.targetResourceType
string
the resource type of the target resource(s) on which the alert is created/updated. Mandatory if the scope contains a subscription, resource group, or more than one resource.
properties.windowSize
string
the period of time (in ISO 8601 duration format) that is used to monitor alert activity based on the threshold.
tags
object
Resource tags
type
string
Azure resource type
MetricAlertSingleResourceMultipleMetricCriteria
Object
Specifies the metric alert criteria for a single resource that has multiple metric criteria.
Expand table
Name
Type
Description
allOf
MetricCriteria []
The list of metric criteria for this 'all of' operation.
odata.type
string:
Microsoft.Azure.Monitor.SingleResourceMultipleMetricCriteria
specifies the type of the alert criteria.
Object
Criterion to filter metrics.
Expand table
Name
Type
Description
criterionType
string:
StaticThresholdCriterion
Specifies the type of threshold criteria
dimensions
MetricDimension []
List of dimension conditions.
metricName
string
Name of the metric.
metricNamespace
string
Namespace of the metric.
name
string
Name of the criteria.
operator
Operator
the criteria operator.
skipMetricValidation
boolean
Allows creating an alert rule on a custom metric that isn't yet emitted, by causing the metric validation to be skipped.
threshold
number
the criteria threshold value that activates the alert.
timeAggregation
AggregationTypeEnum
the criteria time aggregation types.
Object
Specifies a metric dimension.
Expand table
Name
Type
Description
name
string
Name of the dimension.
operator
string
the dimension operator. Only 'Include' and 'Exclude' are supported
values
string[]
list of dimension values.
Enumeration
the criteria operator.
Expand table
Value
Description
Equals
GreaterThan
GreaterThanOrEqual
LessThan
LessThanOrEqual
WebtestLocationAvailabilityCriteria
Object
Specifies the metric alert rule criteria for a web test resource.
Expand table
Name
Type
Description
componentId
string
The Application Insights resource Id.
failedLocationCount
number
The number of failed locations.
odata.type
string:
Microsoft.Azure.Monitor.WebtestLocationAvailabilityCriteria
specifies the type of the alert criteria.
webTestId
string
The Application Insights web test Id.