azure.monitoring.AlertPrometheusRuleGroup

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const exampleActionGroup = new azure.monitoring.ActionGroup("example", {
    name: "example-mag",
    resourceGroupName: example.name,
    shortName: "testag",
});
const exampleWorkspace = new azure.monitoring.Workspace("example", {
    name: "example-amw",
    resourceGroupName: example.name,
    location: example.location,
});
const exampleKubernetesCluster = new azure.containerservice.KubernetesCluster("example", {
    name: "example-cluster",
    location: example.location,
    resourceGroupName: example.name,
    dnsPrefix: "example-aks",
    defaultNodePool: {
        name: "default",
        nodeCount: 1,
        vmSize: "Standard_DS2_v2",
        hostEncryptionEnabled: true,
    },
    identity: {
        type: "SystemAssigned",
    },
});
const exampleAlertPrometheusRuleGroup = new azure.monitoring.AlertPrometheusRuleGroup("example", {
    name: "example-amprg",
    location: "West Europe",
    resourceGroupName: example.name,
    clusterName: exampleKubernetesCluster.name,
    description: "This is the description of the following rule group",
    ruleGroupEnabled: false,
    interval: "PT1M",
    scopes: [exampleWorkspace.id],
    rules: [
        {
            enabled: false,
            expression: "histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service=\"billing-processing\"}[5m])) by (job_type))\n",
            record: "job_type:billing_jobs_duration_seconds:99p5m",
            labels: {
                team: "prod",
            },
        },
        {
            alert: "Billing_Processing_Very_Slow",
            enabled: true,
            expression: "histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service=\"billing-processing\"}[5m])) by (job_type))\n",
            "for": "PT5M",
            severity: 2,
            actions: [{
                actionGroupId: exampleActionGroup.id,
            }],
            alertResolution: {
                autoResolved: true,
                timeToResolve: "PT10M",
            },
            annotations: {
                annotationName: "annotationValue",
            },
            labels: {
                team: "prod",
            },
        },
    ],
    tags: {
        key: "value",
    },
});

import pulumi
import pulumi_azure as azure

example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example_action_group = azure.monitoring.ActionGroup("example",
    name="example-mag",
    resource_group_name=example.name,
    short_name="testag")
example_workspace = azure.monitoring.Workspace("example",
    name="example-amw",
    resource_group_name=example.name,
    location=example.location)
example_kubernetes_cluster = azure.containerservice.KubernetesCluster("example",
    name="example-cluster",
    location=example.location,
    resource_group_name=example.name,
    dns_prefix="example-aks",
    default_node_pool={
        "name": "default",
        "node_count": 1,
        "vm_size": "Standard_DS2_v2",
        "host_encryption_enabled": True,
    },
    identity={
        "type": "SystemAssigned",
    })
example_alert_prometheus_rule_group = azure.monitoring.AlertPrometheusRuleGroup("example",
    name="example-amprg",
    location="West Europe",
    resource_group_name=example.name,
    cluster_name=example_kubernetes_cluster.name,
    description="This is the description of the following rule group",
    rule_group_enabled=False,
    interval="PT1M",
    scopes=[example_workspace.id],
    rules=[
        {
            "enabled": False,
            "expression": "histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service=\"billing-processing\"}[5m])) by (job_type))\n",
            "record": "job_type:billing_jobs_duration_seconds:99p5m",
            "labels": {
                "team": "prod",
            },
        },
        {
            "alert": "Billing_Processing_Very_Slow",
            "enabled": True,
            "expression": "histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service=\"billing-processing\"}[5m])) by (job_type))\n",
            "for_": "PT5M",
            "severity": 2,
            "actions": [{
                "action_group_id": example_action_group.id,
            }],
            "alert_resolution": {
                "auto_resolved": True,
                "time_to_resolve": "PT10M",
            },
            "annotations": {
                "annotationName": "annotationValue",
            },
            "labels": {
                "team": "prod",
            },
        },
    ],
    tags={
        "key": "value",
    })

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/containerservice"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/monitoring"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleActionGroup, err := monitoring.NewActionGroup(ctx, "example", &monitoring.ActionGroupArgs{
			Name:              pulumi.String("example-mag"),
			ResourceGroupName: example.Name,
			ShortName:         pulumi.String("testag"),
		})
		if err != nil {
			return err
		}
		exampleWorkspace, err := monitoring.NewWorkspace(ctx, "example", &monitoring.WorkspaceArgs{
			Name:              pulumi.String("example-amw"),
			ResourceGroupName: example.Name,
			Location:          example.Location,
		})
		if err != nil {
			return err
		}
		exampleKubernetesCluster, err := containerservice.NewKubernetesCluster(ctx, "example", &containerservice.KubernetesClusterArgs{
			Name:              pulumi.String("example-cluster"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			DnsPrefix:         pulumi.String("example-aks"),
			DefaultNodePool: &containerservice.KubernetesClusterDefaultNodePoolArgs{
				Name:                  pulumi.String("default"),
				NodeCount:             pulumi.Int(1),
				VmSize:                pulumi.String("Standard_DS2_v2"),
				HostEncryptionEnabled: pulumi.Bool(true),
			},
			Identity: &containerservice.KubernetesClusterIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		_, err = monitoring.NewAlertPrometheusRuleGroup(ctx, "example", &monitoring.AlertPrometheusRuleGroupArgs{
			Name:              pulumi.String("example-amprg"),
			Location:          pulumi.String("West Europe"),
			ResourceGroupName: example.Name,
			ClusterName:       exampleKubernetesCluster.Name,
			Description:       pulumi.String("This is the description of the following rule group"),
			RuleGroupEnabled:  pulumi.Bool(false),
			Interval:          pulumi.String("PT1M"),
			Scopes: pulumi.StringArray{
				exampleWorkspace.ID(),
			},
			Rules: monitoring.AlertPrometheusRuleGroupRuleArray{
				&monitoring.AlertPrometheusRuleGroupRuleArgs{
					Enabled:    pulumi.Bool(false),
					Expression: pulumi.String("histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service=\"billing-processing\"}[5m])) by (job_type))\n"),
					Record:     pulumi.String("job_type:billing_jobs_duration_seconds:99p5m"),
					Labels: pulumi.StringMap{
						"team": pulumi.String("prod"),
					},
				},
				&monitoring.AlertPrometheusRuleGroupRuleArgs{
					Alert:      pulumi.String("Billing_Processing_Very_Slow"),
					Enabled:    pulumi.Bool(true),
					Expression: pulumi.String("histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service=\"billing-processing\"}[5m])) by (job_type))\n"),
					For:        pulumi.String("PT5M"),
					Severity:   pulumi.Int(2),
					Actions: monitoring.AlertPrometheusRuleGroupRuleActionArray{
						&monitoring.AlertPrometheusRuleGroupRuleActionArgs{
							ActionGroupId: exampleActionGroup.ID(),
						},
					},
					AlertResolution: &monitoring.AlertPrometheusRuleGroupRuleAlertResolutionArgs{
						AutoResolved:  pulumi.Bool(true),
						TimeToResolve: pulumi.String("PT10M"),
					},
					Annotations: pulumi.StringMap{
						"annotationName": pulumi.String("annotationValue"),
					},
					Labels: pulumi.StringMap{
						"team": pulumi.String("prod"),
					},
				},
			},
			Tags: pulumi.StringMap{
				"key": pulumi.String("value"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });

    var exampleActionGroup = new Azure.Monitoring.ActionGroup("example", new()
    {
        Name = "example-mag",
        ResourceGroupName = example.Name,
        ShortName = "testag",
    });

    var exampleWorkspace = new Azure.Monitoring.Workspace("example", new()
    {
        Name = "example-amw",
        ResourceGroupName = example.Name,
        Location = example.Location,
    });

    var exampleKubernetesCluster = new Azure.ContainerService.KubernetesCluster("example", new()
    {
        Name = "example-cluster",
        Location = example.Location,
        ResourceGroupName = example.Name,
        DnsPrefix = "example-aks",
        DefaultNodePool = new Azure.ContainerService.Inputs.KubernetesClusterDefaultNodePoolArgs
        {
            Name = "default",
            NodeCount = 1,
            VmSize = "Standard_DS2_v2",
            HostEncryptionEnabled = true,
        },
        Identity = new Azure.ContainerService.Inputs.KubernetesClusterIdentityArgs
        {
            Type = "SystemAssigned",
        },
    });

    var exampleAlertPrometheusRuleGroup = new Azure.Monitoring.AlertPrometheusRuleGroup("example", new()
    {
        Name = "example-amprg",
        Location = "West Europe",
        ResourceGroupName = example.Name,
        ClusterName = exampleKubernetesCluster.Name,
        Description = "This is the description of the following rule group",
        RuleGroupEnabled = false,
        Interval = "PT1M",
        Scopes = new[]
        {
            exampleWorkspace.Id,
        },
        Rules = new[]
        {
            new Azure.Monitoring.Inputs.AlertPrometheusRuleGroupRuleArgs
            {
                Enabled = false,
                Expression = @"histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service=""billing-processing""}[5m])) by (job_type))
",
                Record = "job_type:billing_jobs_duration_seconds:99p5m",
                Labels = 
                {
                    { "team", "prod" },
                },
            },
            new Azure.Monitoring.Inputs.AlertPrometheusRuleGroupRuleArgs
            {
                Alert = "Billing_Processing_Very_Slow",
                Enabled = true,
                Expression = @"histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service=""billing-processing""}[5m])) by (job_type))
",
                For = "PT5M",
                Severity = 2,
                Actions = new[]
                {
                    new Azure.Monitoring.Inputs.AlertPrometheusRuleGroupRuleActionArgs
                    {
                        ActionGroupId = exampleActionGroup.Id,
                    },
                },
                AlertResolution = new Azure.Monitoring.Inputs.AlertPrometheusRuleGroupRuleAlertResolutionArgs
                {
                    AutoResolved = true,
                    TimeToResolve = "PT10M",
                },
                Annotations = 
                {
                    { "annotationName", "annotationValue" },
                },
                Labels = 
                {
                    { "team", "prod" },
                },
            },
        },
        Tags = 
        {
            { "key", "value" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.monitoring.ActionGroup;
import com.pulumi.azure.monitoring.ActionGroupArgs;
import com.pulumi.azure.monitoring.Workspace;
import com.pulumi.azure.monitoring.WorkspaceArgs;
import com.pulumi.azure.containerservice.KubernetesCluster;
import com.pulumi.azure.containerservice.KubernetesClusterArgs;
import com.pulumi.azure.containerservice.inputs.KubernetesClusterDefaultNodePoolArgs;
import com.pulumi.azure.containerservice.inputs.KubernetesClusterIdentityArgs;
import com.pulumi.azure.monitoring.AlertPrometheusRuleGroup;
import com.pulumi.azure.monitoring.AlertPrometheusRuleGroupArgs;
import com.pulumi.azure.monitoring.inputs.AlertPrometheusRuleGroupRuleArgs;
import com.pulumi.azure.monitoring.inputs.AlertPrometheusRuleGroupRuleAlertResolutionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());

        var exampleActionGroup = new ActionGroup("exampleActionGroup", ActionGroupArgs.builder()
            .name("example-mag")
            .resourceGroupName(example.name())
            .shortName("testag")
            .build());

        var exampleWorkspace = new Workspace("exampleWorkspace", WorkspaceArgs.builder()
            .name("example-amw")
            .resourceGroupName(example.name())
            .location(example.location())
            .build());

        var exampleKubernetesCluster = new KubernetesCluster("exampleKubernetesCluster", KubernetesClusterArgs.builder()
            .name("example-cluster")
            .location(example.location())
            .resourceGroupName(example.name())
            .dnsPrefix("example-aks")
            .defaultNodePool(KubernetesClusterDefaultNodePoolArgs.builder()
                .name("default")
                .nodeCount(1)
                .vmSize("Standard_DS2_v2")
                .hostEncryptionEnabled(true)
                .build())
            .identity(KubernetesClusterIdentityArgs.builder()
                .type("SystemAssigned")
                .build())
            .build());

        var exampleAlertPrometheusRuleGroup = new AlertPrometheusRuleGroup("exampleAlertPrometheusRuleGroup", AlertPrometheusRuleGroupArgs.builder()
            .name("example-amprg")
            .location("West Europe")
            .resourceGroupName(example.name())
            .clusterName(exampleKubernetesCluster.name())
            .description("This is the description of the following rule group")
            .ruleGroupEnabled(false)
            .interval("PT1M")
            .scopes(exampleWorkspace.id())
            .rules(            
                AlertPrometheusRuleGroupRuleArgs.builder()
                    .enabled(false)
                    .expression("""
histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service="billing-processing"}[5m])) by (job_type))
                    """)
                    .record("job_type:billing_jobs_duration_seconds:99p5m")
                    .labels(Map.of("team", "prod"))
                    .build(),
                AlertPrometheusRuleGroupRuleArgs.builder()
                    .alert("Billing_Processing_Very_Slow")
                    .enabled(true)
                    .expression("""
histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service="billing-processing"}[5m])) by (job_type))
                    """)
                    .for_("PT5M")
                    .severity(2)
                    .actions(AlertPrometheusRuleGroupRuleActionArgs.builder()
                        .actionGroupId(exampleActionGroup.id())
                        .build())
                    .alertResolution(AlertPrometheusRuleGroupRuleAlertResolutionArgs.builder()
                        .autoResolved(true)
                        .timeToResolve("PT10M")
                        .build())
                    .annotations(Map.of("annotationName", "annotationValue"))
                    .labels(Map.of("team", "prod"))
                    .build())
            .tags(Map.of("key", "value"))
            .build());

    }
}

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  exampleActionGroup:
    type: azure:monitoring:ActionGroup
    name: example
    properties:
      name: example-mag
      resourceGroupName: ${example.name}
      shortName: testag
  exampleWorkspace:
    type: azure:monitoring:Workspace
    name: example
    properties:
      name: example-amw
      resourceGroupName: ${example.name}
      location: ${example.location}
  exampleKubernetesCluster:
    type: azure:containerservice:KubernetesCluster
    name: example
    properties:
      name: example-cluster
      location: ${example.location}
      resourceGroupName: ${example.name}
      dnsPrefix: example-aks
      defaultNodePool:
        name: default
        nodeCount: 1
        vmSize: Standard_DS2_v2
        hostEncryptionEnabled: true
      identity:
        type: SystemAssigned
  exampleAlertPrometheusRuleGroup:
    type: azure:monitoring:AlertPrometheusRuleGroup
    name: example
    properties:
      name: example-amprg
      location: West Europe
      resourceGroupName: ${example.name}
      clusterName: ${exampleKubernetesCluster.name}
      description: This is the description of the following rule group
      ruleGroupEnabled: false
      interval: PT1M
      scopes:
        - ${exampleWorkspace.id}
      rules:
        - enabled: false
          expression: |
            histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service="billing-processing"}[5m])) by (job_type))            
          record: job_type:billing_jobs_duration_seconds:99p5m
          labels:
            team: prod
        - alert: Billing_Processing_Very_Slow
          enabled: true
          expression: |
            histogram_quantile(0.99, sum(rate(jobs_duration_seconds_bucket{service="billing-processing"}[5m])) by (job_type))            
          for: PT5M
          severity: 2
          actions:
            - actionGroupId: ${exampleActionGroup.id}
          alertResolution:
            autoResolved: true
            timeToResolve: PT10M
          annotations:
            annotationName: annotationValue
          labels:
            team: prod
      tags:
        key: value

var alertPrometheusRuleGroupResource = new Azure.Monitoring.AlertPrometheusRuleGroup("alertPrometheusRuleGroupResource", new()
{
    ResourceGroupName = "string",
    Rules = new[]
    {
        new Azure.Monitoring.Inputs.AlertPrometheusRuleGroupRuleArgs
        {
            Expression = "string",
            Actions = new[]
            {
                new Azure.Monitoring.Inputs.AlertPrometheusRuleGroupRuleActionArgs
                {
                    ActionGroupId = "string",
                    ActionProperties = 
                    {
                        { "string", "string" },
                    },
                },
            },
            Alert = "string",
            AlertResolution = new Azure.Monitoring.Inputs.AlertPrometheusRuleGroupRuleAlertResolutionArgs
            {
                AutoResolved = false,
                TimeToResolve = "string",
            },
            Annotations = 
            {
                { "string", "string" },
            },
            Enabled = false,
            For = "string",
            Labels = 
            {
                { "string", "string" },
            },
            Record = "string",
            Severity = 0,
        },
    },
    Scopes = new[]
    {
        "string",
    },
    ClusterName = "string",
    Description = "string",
    Interval = "string",
    Location = "string",
    Name = "string",
    RuleGroupEnabled = false,
    Tags = 
    {
        { "string", "string" },
    },
});

example, err := monitoring.NewAlertPrometheusRuleGroup(ctx, "alertPrometheusRuleGroupResource", &monitoring.AlertPrometheusRuleGroupArgs{
	ResourceGroupName: pulumi.String("string"),
	Rules: monitoring.AlertPrometheusRuleGroupRuleArray{
		&monitoring.AlertPrometheusRuleGroupRuleArgs{
			Expression: pulumi.String("string"),
			Actions: monitoring.AlertPrometheusRuleGroupRuleActionArray{
				&monitoring.AlertPrometheusRuleGroupRuleActionArgs{
					ActionGroupId: pulumi.String("string"),
					ActionProperties: pulumi.StringMap{
						"string": pulumi.String("string"),
					},
				},
			},
			Alert: pulumi.String("string"),
			AlertResolution: &monitoring.AlertPrometheusRuleGroupRuleAlertResolutionArgs{
				AutoResolved:  pulumi.Bool(false),
				TimeToResolve: pulumi.String("string"),
			},
			Annotations: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
			Enabled: pulumi.Bool(false),
			For:     pulumi.String("string"),
			Labels: pulumi.StringMap{
				"string": pulumi.String("string"),
			},
			Record:   pulumi.String("string"),
			Severity: pulumi.Int(0),
		},
	},
	Scopes: pulumi.StringArray{
		pulumi.String("string"),
	},
	ClusterName:      pulumi.String("string"),
	Description:      pulumi.String("string"),
	Interval:         pulumi.String("string"),
	Location:         pulumi.String("string"),
	Name:             pulumi.String("string"),
	RuleGroupEnabled: pulumi.Bool(false),
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
})

var alertPrometheusRuleGroupResource = new AlertPrometheusRuleGroup("alertPrometheusRuleGroupResource", AlertPrometheusRuleGroupArgs.builder()
    .resourceGroupName("string")
    .rules(AlertPrometheusRuleGroupRuleArgs.builder()
        .expression("string")
        .actions(AlertPrometheusRuleGroupRuleActionArgs.builder()
            .actionGroupId("string")
            .actionProperties(Map.of("string", "string"))
            .build())
        .alert("string")
        .alertResolution(AlertPrometheusRuleGroupRuleAlertResolutionArgs.builder()
            .autoResolved(false)
            .timeToResolve("string")
            .build())
        .annotations(Map.of("string", "string"))
        .enabled(false)
        .for_("string")
        .labels(Map.of("string", "string"))
        .record("string")
        .severity(0)
        .build())
    .scopes("string")
    .clusterName("string")
    .description("string")
    .interval("string")
    .location("string")
    .name("string")
    .ruleGroupEnabled(false)
    .tags(Map.of("string", "string"))
    .build());

alert_prometheus_rule_group_resource = azure.monitoring.AlertPrometheusRuleGroup("alertPrometheusRuleGroupResource",
    resource_group_name="string",
    rules=[{
        "expression": "string",
        "actions": [{
            "action_group_id": "string",
            "action_properties": {
                "string": "string",
            },
        }],
        "alert": "string",
        "alert_resolution": {
            "auto_resolved": False,
            "time_to_resolve": "string",
        },
        "annotations": {
            "string": "string",
        },
        "enabled": False,
        "for_": "string",
        "labels": {
            "string": "string",
        },
        "record": "string",
        "severity": 0,
    }],
    scopes=["string"],
    cluster_name="string",
    description="string",
    interval="string",
    location="string",
    name="string",
    rule_group_enabled=False,
    tags={
        "string": "string",
    })

const alertPrometheusRuleGroupResource = new azure.monitoring.AlertPrometheusRuleGroup("alertPrometheusRuleGroupResource", {
    resourceGroupName: "string",
    rules: [{
        expression: "string",
        actions: [{
            actionGroupId: "string",
            actionProperties: {
                string: "string",
            },
        }],
        alert: "string",
        alertResolution: {
            autoResolved: false,
            timeToResolve: "string",
        },
        annotations: {
            string: "string",
        },
        enabled: false,
        "for": "string",
        labels: {
            string: "string",
        },
        record: "string",
        severity: 0,
    }],
    scopes: ["string"],
    clusterName: "string",
    description: "string",
    interval: "string",
    location: "string",
    name: "string",
    ruleGroupEnabled: false,
    tags: {
        string: "string",
    },
});

type: azure:monitoring:AlertPrometheusRuleGroup
properties:
    clusterName: string
    description: string
    interval: string
    location: string
    name: string
    resourceGroupName: string
    ruleGroupEnabled: false
    rules:
        - actions:
            - actionGroupId: string
              actionProperties:
                string: string
          alert: string
          alertResolution:
            autoResolved: false
            timeToResolve: string
          annotations:
            string: string
          enabled: false
          expression: string
          for: string
          labels:
            string: string
          record: string
          severity: 0
    scopes:
        - string
    tags:
        string: string