1. Packages
  2. Grafana Cloud
  3. API Docs
  4. RuleGroup
Grafana v0.5.1 published on Wednesday, Jun 12, 2024 by pulumiverse

grafana.RuleGroup

Explore with Pulumi AI

grafana logo
Grafana v0.5.1 published on Wednesday, Jun 12, 2024 by pulumiverse

    Manages Grafana Alerting rule groups.

    This resource requires Grafana 9.1.0 or later.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as grafana from "@pulumiverse/grafana";
    
    const ruleFolder = new grafana.Folder("ruleFolder", {title: "My Alert Rule Folder"});
    const myAlertRule = new grafana.RuleGroup("myAlertRule", {
        folderUid: ruleFolder.uid,
        intervalSeconds: 240,
        orgId: "1",
        rules: [{
            name: "My Alert Rule 1",
            "for": "2m",
            condition: "B",
            noDataState: "NoData",
            execErrState: "Alerting",
            annotations: {
                a: "b",
                c: "d",
            },
            labels: {
                e: "f",
                g: "h",
            },
            isPaused: false,
            datas: [
                {
                    refId: "A",
                    queryType: "",
                    relativeTimeRange: {
                        from: 600,
                        to: 0,
                    },
                    datasourceUid: "PD8C576611E62080A",
                    model: JSON.stringify({
                        hide: false,
                        intervalMs: 1000,
                        maxDataPoints: 43200,
                        refId: "A",
                    }),
                },
                {
                    refId: "B",
                    queryType: "",
                    relativeTimeRange: {
                        from: 0,
                        to: 0,
                    },
                    datasourceUid: "-100",
                    model: `{
        "conditions": [
            {
            "evaluator": {
                "params": [
                3
                ],
                "type": "gt"
            },
            "operator": {
                "type": "and"
            },
            "query": {
                "params": [
                "A"
                ]
            },
            "reducer": {
                "params": [],
                "type": "last"
            },
            "type": "query"
            }
        ],
        "datasource": {
            "type": "__expr__",
            "uid": "-100"
        },
        "hide": false,
        "intervalMs": 1000,
        "maxDataPoints": 43200,
        "refId": "B",
        "type": "classic_conditions"
    }
    `,
                },
            ],
        }],
    });
    
    import pulumi
    import json
    import pulumiverse_grafana as grafana
    
    rule_folder = grafana.Folder("ruleFolder", title="My Alert Rule Folder")
    my_alert_rule = grafana.RuleGroup("myAlertRule",
        folder_uid=rule_folder.uid,
        interval_seconds=240,
        org_id="1",
        rules=[grafana.RuleGroupRuleArgs(
            name="My Alert Rule 1",
            for_="2m",
            condition="B",
            no_data_state="NoData",
            exec_err_state="Alerting",
            annotations={
                "a": "b",
                "c": "d",
            },
            labels={
                "e": "f",
                "g": "h",
            },
            is_paused=False,
            datas=[
                grafana.RuleGroupRuleDataArgs(
                    ref_id="A",
                    query_type="",
                    relative_time_range=grafana.RuleGroupRuleDataRelativeTimeRangeArgs(
                        from_=600,
                        to=0,
                    ),
                    datasource_uid="PD8C576611E62080A",
                    model=json.dumps({
                        "hide": False,
                        "intervalMs": 1000,
                        "maxDataPoints": 43200,
                        "refId": "A",
                    }),
                ),
                grafana.RuleGroupRuleDataArgs(
                    ref_id="B",
                    query_type="",
                    relative_time_range=grafana.RuleGroupRuleDataRelativeTimeRangeArgs(
                        from_=0,
                        to=0,
                    ),
                    datasource_uid="-100",
                    model="""{
        "conditions": [
            {
            "evaluator": {
                "params": [
                3
                ],
                "type": "gt"
            },
            "operator": {
                "type": "and"
            },
            "query": {
                "params": [
                "A"
                ]
            },
            "reducer": {
                "params": [],
                "type": "last"
            },
            "type": "query"
            }
        ],
        "datasource": {
            "type": "__expr__",
            "uid": "-100"
        },
        "hide": false,
        "intervalMs": 1000,
        "maxDataPoints": 43200,
        "refId": "B",
        "type": "classic_conditions"
    }
    """,
                ),
            ],
        )])
    
    package main
    
    import (
    	"encoding/json"
    
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    	"github.com/pulumiverse/pulumi-grafana/sdk/go/grafana"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		ruleFolder, err := grafana.NewFolder(ctx, "ruleFolder", &grafana.FolderArgs{
    			Title: pulumi.String("My Alert Rule Folder"),
    		})
    		if err != nil {
    			return err
    		}
    		tmpJSON0, err := json.Marshal(map[string]interface{}{
    			"hide":          false,
    			"intervalMs":    1000,
    			"maxDataPoints": 43200,
    			"refId":         "A",
    		})
    		if err != nil {
    			return err
    		}
    		json0 := string(tmpJSON0)
    		_, err = grafana.NewRuleGroup(ctx, "myAlertRule", &grafana.RuleGroupArgs{
    			FolderUid:       ruleFolder.Uid,
    			IntervalSeconds: pulumi.Int(240),
    			OrgId:           pulumi.String("1"),
    			Rules: grafana.RuleGroupRuleArray{
    				&grafana.RuleGroupRuleArgs{
    					Name:         pulumi.String("My Alert Rule 1"),
    					For:          pulumi.String("2m"),
    					Condition:    pulumi.String("B"),
    					NoDataState:  pulumi.String("NoData"),
    					ExecErrState: pulumi.String("Alerting"),
    					Annotations: pulumi.StringMap{
    						"a": pulumi.String("b"),
    						"c": pulumi.String("d"),
    					},
    					Labels: pulumi.StringMap{
    						"e": pulumi.String("f"),
    						"g": pulumi.String("h"),
    					},
    					IsPaused: pulumi.Bool(false),
    					Datas: grafana.RuleGroupRuleDataArray{
    						&grafana.RuleGroupRuleDataArgs{
    							RefId:     pulumi.String("A"),
    							QueryType: pulumi.String(""),
    							RelativeTimeRange: &grafana.RuleGroupRuleDataRelativeTimeRangeArgs{
    								From: pulumi.Int(600),
    								To:   pulumi.Int(0),
    							},
    							DatasourceUid: pulumi.String("PD8C576611E62080A"),
    							Model:         pulumi.String(json0),
    						},
    						&grafana.RuleGroupRuleDataArgs{
    							RefId:     pulumi.String("B"),
    							QueryType: pulumi.String(""),
    							RelativeTimeRange: &grafana.RuleGroupRuleDataRelativeTimeRangeArgs{
    								From: pulumi.Int(0),
    								To:   pulumi.Int(0),
    							},
    							DatasourceUid: pulumi.String("-100"),
    							Model: pulumi.String(`{
        "conditions": [
            {
            "evaluator": {
                "params": [
                3
                ],
                "type": "gt"
            },
            "operator": {
                "type": "and"
            },
            "query": {
                "params": [
                "A"
                ]
            },
            "reducer": {
                "params": [],
                "type": "last"
            },
            "type": "query"
            }
        ],
        "datasource": {
            "type": "__expr__",
            "uid": "-100"
        },
        "hide": false,
        "intervalMs": 1000,
        "maxDataPoints": 43200,
        "refId": "B",
        "type": "classic_conditions"
    }
    `),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using System.Text.Json;
    using Pulumi;
    using Grafana = Pulumiverse.Grafana;
    
    return await Deployment.RunAsync(() => 
    {
        var ruleFolder = new Grafana.Folder("ruleFolder", new()
        {
            Title = "My Alert Rule Folder",
        });
    
        var myAlertRule = new Grafana.RuleGroup("myAlertRule", new()
        {
            FolderUid = ruleFolder.Uid,
            IntervalSeconds = 240,
            OrgId = "1",
            Rules = new[]
            {
                new Grafana.Inputs.RuleGroupRuleArgs
                {
                    Name = "My Alert Rule 1",
                    For = "2m",
                    Condition = "B",
                    NoDataState = "NoData",
                    ExecErrState = "Alerting",
                    Annotations = 
                    {
                        { "a", "b" },
                        { "c", "d" },
                    },
                    Labels = 
                    {
                        { "e", "f" },
                        { "g", "h" },
                    },
                    IsPaused = false,
                    Datas = new[]
                    {
                        new Grafana.Inputs.RuleGroupRuleDataArgs
                        {
                            RefId = "A",
                            QueryType = "",
                            RelativeTimeRange = new Grafana.Inputs.RuleGroupRuleDataRelativeTimeRangeArgs
                            {
                                From = 600,
                                To = 0,
                            },
                            DatasourceUid = "PD8C576611E62080A",
                            Model = JsonSerializer.Serialize(new Dictionary<string, object?>
                            {
                                ["hide"] = false,
                                ["intervalMs"] = 1000,
                                ["maxDataPoints"] = 43200,
                                ["refId"] = "A",
                            }),
                        },
                        new Grafana.Inputs.RuleGroupRuleDataArgs
                        {
                            RefId = "B",
                            QueryType = "",
                            RelativeTimeRange = new Grafana.Inputs.RuleGroupRuleDataRelativeTimeRangeArgs
                            {
                                From = 0,
                                To = 0,
                            },
                            DatasourceUid = "-100",
                            Model = @"{
        ""conditions"": [
            {
            ""evaluator"": {
                ""params"": [
                3
                ],
                ""type"": ""gt""
            },
            ""operator"": {
                ""type"": ""and""
            },
            ""query"": {
                ""params"": [
                ""A""
                ]
            },
            ""reducer"": {
                ""params"": [],
                ""type"": ""last""
            },
            ""type"": ""query""
            }
        ],
        ""datasource"": {
            ""type"": ""__expr__"",
            ""uid"": ""-100""
        },
        ""hide"": false,
        ""intervalMs"": 1000,
        ""maxDataPoints"": 43200,
        ""refId"": ""B"",
        ""type"": ""classic_conditions""
    }
    ",
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.grafana.Folder;
    import com.pulumi.grafana.FolderArgs;
    import com.pulumi.grafana.RuleGroup;
    import com.pulumi.grafana.RuleGroupArgs;
    import com.pulumi.grafana.inputs.RuleGroupRuleArgs;
    import static com.pulumi.codegen.internal.Serialization.*;
    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 ruleFolder = new Folder("ruleFolder", FolderArgs.builder()        
                .title("My Alert Rule Folder")
                .build());
    
            var myAlertRule = new RuleGroup("myAlertRule", RuleGroupArgs.builder()        
                .folderUid(ruleFolder.uid())
                .intervalSeconds(240)
                .orgId(1)
                .rules(RuleGroupRuleArgs.builder()
                    .name("My Alert Rule 1")
                    .for_("2m")
                    .condition("B")
                    .noDataState("NoData")
                    .execErrState("Alerting")
                    .annotations(Map.ofEntries(
                        Map.entry("a", "b"),
                        Map.entry("c", "d")
                    ))
                    .labels(Map.ofEntries(
                        Map.entry("e", "f"),
                        Map.entry("g", "h")
                    ))
                    .isPaused(false)
                    .datas(                
                        RuleGroupRuleDataArgs.builder()
                            .refId("A")
                            .queryType("")
                            .relativeTimeRange(RuleGroupRuleDataRelativeTimeRangeArgs.builder()
                                .from(600)
                                .to(0)
                                .build())
                            .datasourceUid("PD8C576611E62080A")
                            .model(serializeJson(
                                jsonObject(
                                    jsonProperty("hide", false),
                                    jsonProperty("intervalMs", 1000),
                                    jsonProperty("maxDataPoints", 43200),
                                    jsonProperty("refId", "A")
                                )))
                            .build(),
                        RuleGroupRuleDataArgs.builder()
                            .refId("B")
                            .queryType("")
                            .relativeTimeRange(RuleGroupRuleDataRelativeTimeRangeArgs.builder()
                                .from(0)
                                .to(0)
                                .build())
                            .datasourceUid("-100")
                            .model("""
    {
        "conditions": [
            {
            "evaluator": {
                "params": [
                3
                ],
                "type": "gt"
            },
            "operator": {
                "type": "and"
            },
            "query": {
                "params": [
                "A"
                ]
            },
            "reducer": {
                "params": [],
                "type": "last"
            },
            "type": "query"
            }
        ],
        "datasource": {
            "type": "__expr__",
            "uid": "-100"
        },
        "hide": false,
        "intervalMs": 1000,
        "maxDataPoints": 43200,
        "refId": "B",
        "type": "classic_conditions"
    }
                            """)
                            .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      ruleFolder:
        type: grafana:Folder
        properties:
          title: My Alert Rule Folder
      myAlertRule:
        type: grafana:RuleGroup
        properties:
          folderUid: ${ruleFolder.uid}
          intervalSeconds: 240
          orgId: 1
          rules:
            - name: My Alert Rule 1
              for: 2m
              condition: B
              noDataState: NoData
              execErrState: Alerting
              annotations:
                a: b
                c: d
              labels:
                e: f
                g: h
              isPaused: false
              datas:
                - refId: A
                  queryType:
                  relativeTimeRange:
                    from: 600
                    to: 0
                  datasourceUid: PD8C576611E62080A
                  model:
                    fn::toJSON:
                      hide: false
                      intervalMs: 1000
                      maxDataPoints: 43200
                      refId: A
                - refId: B
                  queryType:
                  relativeTimeRange:
                    from: 0
                    to: 0
                  datasourceUid: '-100'
                  model: |
                    {
                        "conditions": [
                            {
                            "evaluator": {
                                "params": [
                                3
                                ],
                                "type": "gt"
                            },
                            "operator": {
                                "type": "and"
                            },
                            "query": {
                                "params": [
                                "A"
                                ]
                            },
                            "reducer": {
                                "params": [],
                                "type": "last"
                            },
                            "type": "query"
                            }
                        ],
                        "datasource": {
                            "type": "__expr__",
                            "uid": "-100"
                        },
                        "hide": false,
                        "intervalMs": 1000,
                        "maxDataPoints": 43200,
                        "refId": "B",
                        "type": "classic_conditions"
                    }                
    

    Create RuleGroup Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new RuleGroup(name: string, args: RuleGroupArgs, opts?: CustomResourceOptions);
    @overload
    def RuleGroup(resource_name: str,
                  args: RuleGroupArgs,
                  opts: Optional[ResourceOptions] = None)
    
    @overload
    def RuleGroup(resource_name: str,
                  opts: Optional[ResourceOptions] = None,
                  folder_uid: Optional[str] = None,
                  interval_seconds: Optional[int] = None,
                  rules: Optional[Sequence[RuleGroupRuleArgs]] = None,
                  disable_provenance: Optional[bool] = None,
                  name: Optional[str] = None,
                  org_id: Optional[str] = None)
    func NewRuleGroup(ctx *Context, name string, args RuleGroupArgs, opts ...ResourceOption) (*RuleGroup, error)
    public RuleGroup(string name, RuleGroupArgs args, CustomResourceOptions? opts = null)
    public RuleGroup(String name, RuleGroupArgs args)
    public RuleGroup(String name, RuleGroupArgs args, CustomResourceOptions options)
    
    type: grafana:RuleGroup
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args RuleGroupArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args RuleGroupArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args RuleGroupArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RuleGroupArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RuleGroupArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var ruleGroupResource = new Grafana.RuleGroup("ruleGroupResource", new()
    {
        FolderUid = "string",
        IntervalSeconds = 0,
        Rules = new[]
        {
            new Grafana.Inputs.RuleGroupRuleArgs
            {
                Condition = "string",
                Datas = new[]
                {
                    new Grafana.Inputs.RuleGroupRuleDataArgs
                    {
                        DatasourceUid = "string",
                        Model = "string",
                        RefId = "string",
                        RelativeTimeRange = new Grafana.Inputs.RuleGroupRuleDataRelativeTimeRangeArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        QueryType = "string",
                    },
                },
                Name = "string",
                Annotations = 
                {
                    { "string", "string" },
                },
                ExecErrState = "string",
                For = "string",
                IsPaused = false,
                Labels = 
                {
                    { "string", "string" },
                },
                NoDataState = "string",
                NotificationSettings = new Grafana.Inputs.RuleGroupRuleNotificationSettingsArgs
                {
                    ContactPoint = "string",
                    GroupBies = new[]
                    {
                        "string",
                    },
                    GroupInterval = "string",
                    GroupWait = "string",
                    MuteTimings = new[]
                    {
                        "string",
                    },
                    RepeatInterval = "string",
                },
                Uid = "string",
            },
        },
        DisableProvenance = false,
        Name = "string",
        OrgId = "string",
    });
    
    example, err := grafana.NewRuleGroup(ctx, "ruleGroupResource", &grafana.RuleGroupArgs{
    	FolderUid:       pulumi.String("string"),
    	IntervalSeconds: pulumi.Int(0),
    	Rules: grafana.RuleGroupRuleArray{
    		&grafana.RuleGroupRuleArgs{
    			Condition: pulumi.String("string"),
    			Datas: grafana.RuleGroupRuleDataArray{
    				&grafana.RuleGroupRuleDataArgs{
    					DatasourceUid: pulumi.String("string"),
    					Model:         pulumi.String("string"),
    					RefId:         pulumi.String("string"),
    					RelativeTimeRange: &grafana.RuleGroupRuleDataRelativeTimeRangeArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					QueryType: pulumi.String("string"),
    				},
    			},
    			Name: pulumi.String("string"),
    			Annotations: pulumi.StringMap{
    				"string": pulumi.String("string"),
    			},
    			ExecErrState: pulumi.String("string"),
    			For:          pulumi.String("string"),
    			IsPaused:     pulumi.Bool(false),
    			Labels: pulumi.StringMap{
    				"string": pulumi.String("string"),
    			},
    			NoDataState: pulumi.String("string"),
    			NotificationSettings: &grafana.RuleGroupRuleNotificationSettingsArgs{
    				ContactPoint: pulumi.String("string"),
    				GroupBies: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				GroupInterval: pulumi.String("string"),
    				GroupWait:     pulumi.String("string"),
    				MuteTimings: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				RepeatInterval: pulumi.String("string"),
    			},
    			Uid: pulumi.String("string"),
    		},
    	},
    	DisableProvenance: pulumi.Bool(false),
    	Name:              pulumi.String("string"),
    	OrgId:             pulumi.String("string"),
    })
    
    var ruleGroupResource = new RuleGroup("ruleGroupResource", RuleGroupArgs.builder()
        .folderUid("string")
        .intervalSeconds(0)
        .rules(RuleGroupRuleArgs.builder()
            .condition("string")
            .datas(RuleGroupRuleDataArgs.builder()
                .datasourceUid("string")
                .model("string")
                .refId("string")
                .relativeTimeRange(RuleGroupRuleDataRelativeTimeRangeArgs.builder()
                    .from(0)
                    .to(0)
                    .build())
                .queryType("string")
                .build())
            .name("string")
            .annotations(Map.of("string", "string"))
            .execErrState("string")
            .for_("string")
            .isPaused(false)
            .labels(Map.of("string", "string"))
            .noDataState("string")
            .notificationSettings(RuleGroupRuleNotificationSettingsArgs.builder()
                .contactPoint("string")
                .groupBies("string")
                .groupInterval("string")
                .groupWait("string")
                .muteTimings("string")
                .repeatInterval("string")
                .build())
            .uid("string")
            .build())
        .disableProvenance(false)
        .name("string")
        .orgId("string")
        .build());
    
    rule_group_resource = grafana.RuleGroup("ruleGroupResource",
        folder_uid="string",
        interval_seconds=0,
        rules=[grafana.RuleGroupRuleArgs(
            condition="string",
            datas=[grafana.RuleGroupRuleDataArgs(
                datasource_uid="string",
                model="string",
                ref_id="string",
                relative_time_range=grafana.RuleGroupRuleDataRelativeTimeRangeArgs(
                    from_=0,
                    to=0,
                ),
                query_type="string",
            )],
            name="string",
            annotations={
                "string": "string",
            },
            exec_err_state="string",
            for_="string",
            is_paused=False,
            labels={
                "string": "string",
            },
            no_data_state="string",
            notification_settings=grafana.RuleGroupRuleNotificationSettingsArgs(
                contact_point="string",
                group_bies=["string"],
                group_interval="string",
                group_wait="string",
                mute_timings=["string"],
                repeat_interval="string",
            ),
            uid="string",
        )],
        disable_provenance=False,
        name="string",
        org_id="string")
    
    const ruleGroupResource = new grafana.RuleGroup("ruleGroupResource", {
        folderUid: "string",
        intervalSeconds: 0,
        rules: [{
            condition: "string",
            datas: [{
                datasourceUid: "string",
                model: "string",
                refId: "string",
                relativeTimeRange: {
                    from: 0,
                    to: 0,
                },
                queryType: "string",
            }],
            name: "string",
            annotations: {
                string: "string",
            },
            execErrState: "string",
            "for": "string",
            isPaused: false,
            labels: {
                string: "string",
            },
            noDataState: "string",
            notificationSettings: {
                contactPoint: "string",
                groupBies: ["string"],
                groupInterval: "string",
                groupWait: "string",
                muteTimings: ["string"],
                repeatInterval: "string",
            },
            uid: "string",
        }],
        disableProvenance: false,
        name: "string",
        orgId: "string",
    });
    
    type: grafana:RuleGroup
    properties:
        disableProvenance: false
        folderUid: string
        intervalSeconds: 0
        name: string
        orgId: string
        rules:
            - annotations:
                string: string
              condition: string
              datas:
                - datasourceUid: string
                  model: string
                  queryType: string
                  refId: string
                  relativeTimeRange:
                    from: 0
                    to: 0
              execErrState: string
              for: string
              isPaused: false
              labels:
                string: string
              name: string
              noDataState: string
              notificationSettings:
                contactPoint: string
                groupBies:
                    - string
                groupInterval: string
                groupWait: string
                muteTimings:
                    - string
                repeatInterval: string
              uid: string
    

    RuleGroup Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The RuleGroup resource accepts the following input properties:

    FolderUid string
    The UID of the folder that the group belongs to.
    IntervalSeconds int
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    Rules List<Pulumiverse.Grafana.Inputs.RuleGroupRule>
    The rules within the group.
    DisableProvenance bool
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    Name string
    The name of the alert rule.
    OrgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    FolderUid string
    The UID of the folder that the group belongs to.
    IntervalSeconds int
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    Rules []RuleGroupRuleArgs
    The rules within the group.
    DisableProvenance bool
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    Name string
    The name of the alert rule.
    OrgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    folderUid String
    The UID of the folder that the group belongs to.
    intervalSeconds Integer
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    rules List<RuleGroupRule>
    The rules within the group.
    disableProvenance Boolean
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    name String
    The name of the alert rule.
    orgId String
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    folderUid string
    The UID of the folder that the group belongs to.
    intervalSeconds number
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    rules RuleGroupRule[]
    The rules within the group.
    disableProvenance boolean
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    name string
    The name of the alert rule.
    orgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    folder_uid str
    The UID of the folder that the group belongs to.
    interval_seconds int
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    rules Sequence[RuleGroupRuleArgs]
    The rules within the group.
    disable_provenance bool
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    name str
    The name of the alert rule.
    org_id str
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    folderUid String
    The UID of the folder that the group belongs to.
    intervalSeconds Number
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    rules List<Property Map>
    The rules within the group.
    disableProvenance Boolean
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    name String
    The name of the alert rule.
    orgId String
    The Organization ID. If not set, the Org ID defined in the provider block will be used.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the RuleGroup resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing RuleGroup Resource

    Get an existing RuleGroup resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: RuleGroupState, opts?: CustomResourceOptions): RuleGroup
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            disable_provenance: Optional[bool] = None,
            folder_uid: Optional[str] = None,
            interval_seconds: Optional[int] = None,
            name: Optional[str] = None,
            org_id: Optional[str] = None,
            rules: Optional[Sequence[RuleGroupRuleArgs]] = None) -> RuleGroup
    func GetRuleGroup(ctx *Context, name string, id IDInput, state *RuleGroupState, opts ...ResourceOption) (*RuleGroup, error)
    public static RuleGroup Get(string name, Input<string> id, RuleGroupState? state, CustomResourceOptions? opts = null)
    public static RuleGroup get(String name, Output<String> id, RuleGroupState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    DisableProvenance bool
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    FolderUid string
    The UID of the folder that the group belongs to.
    IntervalSeconds int
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    Name string
    The name of the alert rule.
    OrgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    Rules List<Pulumiverse.Grafana.Inputs.RuleGroupRule>
    The rules within the group.
    DisableProvenance bool
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    FolderUid string
    The UID of the folder that the group belongs to.
    IntervalSeconds int
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    Name string
    The name of the alert rule.
    OrgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    Rules []RuleGroupRuleArgs
    The rules within the group.
    disableProvenance Boolean
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    folderUid String
    The UID of the folder that the group belongs to.
    intervalSeconds Integer
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    name String
    The name of the alert rule.
    orgId String
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    rules List<RuleGroupRule>
    The rules within the group.
    disableProvenance boolean
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    folderUid string
    The UID of the folder that the group belongs to.
    intervalSeconds number
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    name string
    The name of the alert rule.
    orgId string
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    rules RuleGroupRule[]
    The rules within the group.
    disable_provenance bool
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    folder_uid str
    The UID of the folder that the group belongs to.
    interval_seconds int
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    name str
    The name of the alert rule.
    org_id str
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    rules Sequence[RuleGroupRuleArgs]
    The rules within the group.
    disableProvenance Boolean
    Allow modifying the rule group from other sources than Terraform or the Grafana API.
    folderUid String
    The UID of the folder that the group belongs to.
    intervalSeconds Number
    The interval, in seconds, at which all rules in the group are evaluated. If a group contains many rules, the rules are evaluated sequentially.
    name String
    The name of the alert rule.
    orgId String
    The Organization ID. If not set, the Org ID defined in the provider block will be used.
    rules List<Property Map>
    The rules within the group.

    Supporting Types

    RuleGroupRule, RuleGroupRuleArgs

    Condition string
    The ref_id of the query node in the data field to use as the alert condition.
    Datas List<Pulumiverse.Grafana.Inputs.RuleGroupRuleData>
    A sequence of stages that describe the contents of the rule.
    Name string
    The name of the alert rule.
    Annotations Dictionary<string, string>
    Key-value pairs of metadata to attach to the alert rule that may add user-defined context, but cannot be used for matching, grouping, or routing. Defaults to map[].
    ExecErrState string
    Describes what state to enter when the rule's query is invalid and the rule cannot be executed. Options are OK, Error, KeepLast, and Alerting. Defaults to Alerting.
    For string
    The amount of time for which the rule must be breached for the rule to be considered to be Firing. Before this time has elapsed, the rule is only considered to be Pending. Defaults to 0.
    IsPaused bool
    Sets whether the alert should be paused or not. Defaults to false.
    Labels Dictionary<string, string>
    Key-value pairs to attach to the alert rule that can be used in matching, grouping, and routing. Defaults to map[].
    NoDataState string
    Describes what state to enter when the rule's query returns No Data. Options are OK, NoData, KeepLast, and Alerting. Defaults to NoData.
    NotificationSettings Pulumiverse.Grafana.Inputs.RuleGroupRuleNotificationSettings
    Notification settings for the rule. If specified, it overrides the notification policies. Available since Grafana 10.4, requires feature flag 'alertingSimplifiedRouting' enabled.
    Uid string
    The unique identifier of the alert rule.
    Condition string
    The ref_id of the query node in the data field to use as the alert condition.
    Datas []RuleGroupRuleData
    A sequence of stages that describe the contents of the rule.
    Name string
    The name of the alert rule.
    Annotations map[string]string
    Key-value pairs of metadata to attach to the alert rule that may add user-defined context, but cannot be used for matching, grouping, or routing. Defaults to map[].
    ExecErrState string
    Describes what state to enter when the rule's query is invalid and the rule cannot be executed. Options are OK, Error, KeepLast, and Alerting. Defaults to Alerting.
    For string
    The amount of time for which the rule must be breached for the rule to be considered to be Firing. Before this time has elapsed, the rule is only considered to be Pending. Defaults to 0.
    IsPaused bool
    Sets whether the alert should be paused or not. Defaults to false.
    Labels map[string]string
    Key-value pairs to attach to the alert rule that can be used in matching, grouping, and routing. Defaults to map[].
    NoDataState string
    Describes what state to enter when the rule's query returns No Data. Options are OK, NoData, KeepLast, and Alerting. Defaults to NoData.
    NotificationSettings RuleGroupRuleNotificationSettings
    Notification settings for the rule. If specified, it overrides the notification policies. Available since Grafana 10.4, requires feature flag 'alertingSimplifiedRouting' enabled.
    Uid string
    The unique identifier of the alert rule.
    condition String
    The ref_id of the query node in the data field to use as the alert condition.
    datas List<RuleGroupRuleData>
    A sequence of stages that describe the contents of the rule.
    name String
    The name of the alert rule.
    annotations Map<String,String>
    Key-value pairs of metadata to attach to the alert rule that may add user-defined context, but cannot be used for matching, grouping, or routing. Defaults to map[].
    execErrState String
    Describes what state to enter when the rule's query is invalid and the rule cannot be executed. Options are OK, Error, KeepLast, and Alerting. Defaults to Alerting.
    for_ String
    The amount of time for which the rule must be breached for the rule to be considered to be Firing. Before this time has elapsed, the rule is only considered to be Pending. Defaults to 0.
    isPaused Boolean
    Sets whether the alert should be paused or not. Defaults to false.
    labels Map<String,String>
    Key-value pairs to attach to the alert rule that can be used in matching, grouping, and routing. Defaults to map[].
    noDataState String
    Describes what state to enter when the rule's query returns No Data. Options are OK, NoData, KeepLast, and Alerting. Defaults to NoData.
    notificationSettings RuleGroupRuleNotificationSettings
    Notification settings for the rule. If specified, it overrides the notification policies. Available since Grafana 10.4, requires feature flag 'alertingSimplifiedRouting' enabled.
    uid String
    The unique identifier of the alert rule.
    condition string
    The ref_id of the query node in the data field to use as the alert condition.
    datas RuleGroupRuleData[]
    A sequence of stages that describe the contents of the rule.
    name string
    The name of the alert rule.
    annotations {[key: string]: string}
    Key-value pairs of metadata to attach to the alert rule that may add user-defined context, but cannot be used for matching, grouping, or routing. Defaults to map[].
    execErrState string
    Describes what state to enter when the rule's query is invalid and the rule cannot be executed. Options are OK, Error, KeepLast, and Alerting. Defaults to Alerting.
    for string
    The amount of time for which the rule must be breached for the rule to be considered to be Firing. Before this time has elapsed, the rule is only considered to be Pending. Defaults to 0.
    isPaused boolean
    Sets whether the alert should be paused or not. Defaults to false.
    labels {[key: string]: string}
    Key-value pairs to attach to the alert rule that can be used in matching, grouping, and routing. Defaults to map[].
    noDataState string
    Describes what state to enter when the rule's query returns No Data. Options are OK, NoData, KeepLast, and Alerting. Defaults to NoData.
    notificationSettings RuleGroupRuleNotificationSettings
    Notification settings for the rule. If specified, it overrides the notification policies. Available since Grafana 10.4, requires feature flag 'alertingSimplifiedRouting' enabled.
    uid string
    The unique identifier of the alert rule.
    condition str
    The ref_id of the query node in the data field to use as the alert condition.
    datas Sequence[RuleGroupRuleData]
    A sequence of stages that describe the contents of the rule.
    name str
    The name of the alert rule.
    annotations Mapping[str, str]
    Key-value pairs of metadata to attach to the alert rule that may add user-defined context, but cannot be used for matching, grouping, or routing. Defaults to map[].
    exec_err_state str
    Describes what state to enter when the rule's query is invalid and the rule cannot be executed. Options are OK, Error, KeepLast, and Alerting. Defaults to Alerting.
    for_ str
    The amount of time for which the rule must be breached for the rule to be considered to be Firing. Before this time has elapsed, the rule is only considered to be Pending. Defaults to 0.
    is_paused bool
    Sets whether the alert should be paused or not. Defaults to false.
    labels Mapping[str, str]
    Key-value pairs to attach to the alert rule that can be used in matching, grouping, and routing. Defaults to map[].
    no_data_state str
    Describes what state to enter when the rule's query returns No Data. Options are OK, NoData, KeepLast, and Alerting. Defaults to NoData.
    notification_settings RuleGroupRuleNotificationSettings
    Notification settings for the rule. If specified, it overrides the notification policies. Available since Grafana 10.4, requires feature flag 'alertingSimplifiedRouting' enabled.
    uid str
    The unique identifier of the alert rule.
    condition String
    The ref_id of the query node in the data field to use as the alert condition.
    datas List<Property Map>
    A sequence of stages that describe the contents of the rule.
    name String
    The name of the alert rule.
    annotations Map<String>
    Key-value pairs of metadata to attach to the alert rule that may add user-defined context, but cannot be used for matching, grouping, or routing. Defaults to map[].
    execErrState String
    Describes what state to enter when the rule's query is invalid and the rule cannot be executed. Options are OK, Error, KeepLast, and Alerting. Defaults to Alerting.
    for String
    The amount of time for which the rule must be breached for the rule to be considered to be Firing. Before this time has elapsed, the rule is only considered to be Pending. Defaults to 0.
    isPaused Boolean
    Sets whether the alert should be paused or not. Defaults to false.
    labels Map<String>
    Key-value pairs to attach to the alert rule that can be used in matching, grouping, and routing. Defaults to map[].
    noDataState String
    Describes what state to enter when the rule's query returns No Data. Options are OK, NoData, KeepLast, and Alerting. Defaults to NoData.
    notificationSettings Property Map
    Notification settings for the rule. If specified, it overrides the notification policies. Available since Grafana 10.4, requires feature flag 'alertingSimplifiedRouting' enabled.
    uid String
    The unique identifier of the alert rule.

    RuleGroupRuleData, RuleGroupRuleDataArgs

    DatasourceUid string
    The UID of the datasource being queried, or "-100" if this stage is an expression stage.
    Model string
    Custom JSON data to send to the specified datasource when querying.
    RefId string
    A unique string to identify this query stage within a rule.
    RelativeTimeRange Pulumiverse.Grafana.Inputs.RuleGroupRuleDataRelativeTimeRange
    The time range, relative to when the query is executed, across which to query.
    QueryType string
    An optional identifier for the type of query being executed. Defaults to ``.
    DatasourceUid string
    The UID of the datasource being queried, or "-100" if this stage is an expression stage.
    Model string
    Custom JSON data to send to the specified datasource when querying.
    RefId string
    A unique string to identify this query stage within a rule.
    RelativeTimeRange RuleGroupRuleDataRelativeTimeRange
    The time range, relative to when the query is executed, across which to query.
    QueryType string
    An optional identifier for the type of query being executed. Defaults to ``.
    datasourceUid String
    The UID of the datasource being queried, or "-100" if this stage is an expression stage.
    model String
    Custom JSON data to send to the specified datasource when querying.
    refId String
    A unique string to identify this query stage within a rule.
    relativeTimeRange RuleGroupRuleDataRelativeTimeRange
    The time range, relative to when the query is executed, across which to query.
    queryType String
    An optional identifier for the type of query being executed. Defaults to ``.
    datasourceUid string
    The UID of the datasource being queried, or "-100" if this stage is an expression stage.
    model string
    Custom JSON data to send to the specified datasource when querying.
    refId string
    A unique string to identify this query stage within a rule.
    relativeTimeRange RuleGroupRuleDataRelativeTimeRange
    The time range, relative to when the query is executed, across which to query.
    queryType string
    An optional identifier for the type of query being executed. Defaults to ``.
    datasource_uid str
    The UID of the datasource being queried, or "-100" if this stage is an expression stage.
    model str
    Custom JSON data to send to the specified datasource when querying.
    ref_id str
    A unique string to identify this query stage within a rule.
    relative_time_range RuleGroupRuleDataRelativeTimeRange
    The time range, relative to when the query is executed, across which to query.
    query_type str
    An optional identifier for the type of query being executed. Defaults to ``.
    datasourceUid String
    The UID of the datasource being queried, or "-100" if this stage is an expression stage.
    model String
    Custom JSON data to send to the specified datasource when querying.
    refId String
    A unique string to identify this query stage within a rule.
    relativeTimeRange Property Map
    The time range, relative to when the query is executed, across which to query.
    queryType String
    An optional identifier for the type of query being executed. Defaults to ``.

    RuleGroupRuleDataRelativeTimeRange, RuleGroupRuleDataRelativeTimeRangeArgs

    From int
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range begins.
    To int
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range ends.
    From int
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range begins.
    To int
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range ends.
    from Integer
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range begins.
    to Integer
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range ends.
    from number
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range begins.
    to number
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range ends.
    from_ int
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range begins.
    to int
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range ends.
    from Number
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range begins.
    to Number
    The number of seconds in the past, relative to when the rule is evaluated, at which the time range ends.

    RuleGroupRuleNotificationSettings, RuleGroupRuleNotificationSettingsArgs

    ContactPoint string
    The contact point to route notifications that match this rule to.
    GroupBies List<string>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. If empty, no grouping is used. If specified, requires labels 'alertname' and 'grafana_folder' to be included.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    MuteTimings List<string>
    A list of mute timing names to apply to alerts that match this policy.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    ContactPoint string
    The contact point to route notifications that match this rule to.
    GroupBies []string
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. If empty, no grouping is used. If specified, requires labels 'alertname' and 'grafana_folder' to be included.
    GroupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    GroupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    MuteTimings []string
    A list of mute timing names to apply to alerts that match this policy.
    RepeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. If empty, no grouping is used. If specified, requires labels 'alertname' and 'grafana_folder' to be included.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint string
    The contact point to route notifications that match this rule to.
    groupBies string[]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. If empty, no grouping is used. If specified, requires labels 'alertname' and 'grafana_folder' to be included.
    groupInterval string
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait string
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    muteTimings string[]
    A list of mute timing names to apply to alerts that match this policy.
    repeatInterval string
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contact_point str
    The contact point to route notifications that match this rule to.
    group_bies Sequence[str]
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. If empty, no grouping is used. If specified, requires labels 'alertname' and 'grafana_folder' to be included.
    group_interval str
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    group_wait str
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    mute_timings Sequence[str]
    A list of mute timing names to apply to alerts that match this policy.
    repeat_interval str
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.
    contactPoint String
    The contact point to route notifications that match this rule to.
    groupBies List<String>
    A list of alert labels to group alerts into notifications by. Use the special label ... to group alerts by all labels, effectively disabling grouping. If empty, no grouping is used. If specified, requires labels 'alertname' and 'grafana_folder' to be included.
    groupInterval String
    Minimum time interval between two notifications for the same group. Default is 5 minutes.
    groupWait String
    Time to wait to buffer alerts of the same group before sending a notification. Default is 30 seconds.
    muteTimings List<String>
    A list of mute timing names to apply to alerts that match this policy.
    repeatInterval String
    Minimum time interval for re-sending a notification if an alert is still firing. Default is 4 hours.

    Import

    $ pulumi import grafana:index/ruleGroup:RuleGroup name "{{ folderUID }}:{{ title }}"
    
    $ pulumi import grafana:index/ruleGroup:RuleGroup name "{{ orgID }}:{{ folderUID }}:{{ title }}"
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    grafana pulumiverse/pulumi-grafana
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the grafana Terraform Provider.
    grafana logo
    Grafana v0.5.1 published on Wednesday, Jun 12, 2024 by pulumiverse