1. Packages
  2. Grafana Cloud
  3. API Docs
  4. alerting
  5. RecordingRuleV0Alpha1
Grafana v2.15.0 published on Wednesday, Nov 12, 2025 by pulumiverse
Schema (JSON)
pulumiverse/pulumi-grafana

grafana.alerting.RecordingRuleV0Alpha1

grafana logo
Grafana v2.15.0 published on Wednesday, Nov 12, 2025 by pulumiverse
Schema (JSON)
pulumiverse/pulumi-grafana

    Manages Grafana Recording Rules.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as grafana from "@pulumiverse/grafana";

const recordingruleFolder = new grafana.oss.Folder("recordingrule_folder", {title: "Alert Rule Folder"});
const example = new grafana.alerting.RecordingRuleV0Alpha1("example", {
    metadata: {
        uid: "example-recording-rule",
        folderUid: recordingruleFolder.uid,
    },
    spec: {
        title: "Example Recording Rule",
        trigger: {
            interval: "1m",
        },
        paused: true,
        expressions: {
            A: {
                model: {
                    editorMode: "code",
                    expr: "count(up{})",
                    instant: true,
                    intervalMs: 1000,
                    legendFormat: "__auto",
                    maxDataPoints: 43200,
                    range: false,
                    refId: "A",
                },
                datasourceUid: "ds_uid",
                relativeTimeRange: {
                    from: "600s",
                    to: "0s",
                },
                queryType: "",
                source: true,
            },
        },
        targetDatasourceUid: "target_ds_uid",
        metric: "tf-metric",
        labels: {
            foo: "bar",
        },
    },
});

    import pulumi
import pulumiverse_grafana as grafana

recordingrule_folder = grafana.oss.Folder("recordingrule_folder", title="Alert Rule Folder")
example = grafana.alerting.RecordingRuleV0Alpha1("example",
    metadata={
        "uid": "example-recording-rule",
        "folder_uid": recordingrule_folder.uid,
    },
    spec={
        "title": "Example Recording Rule",
        "trigger": {
            "interval": "1m",
        },
        "paused": True,
        "expressions": {
            "A": {
                "model": {
                    "editorMode": "code",
                    "expr": "count(up{})",
                    "instant": True,
                    "intervalMs": 1000,
                    "legendFormat": "__auto",
                    "maxDataPoints": 43200,
                    "range": False,
                    "refId": "A",
                },
                "datasourceUid": "ds_uid",
                "relativeTimeRange": {
                    "from": "600s",
                    "to": "0s",
                },
                "queryType": "",
                "source": True,
            },
        },
        "target_datasource_uid": "target_ds_uid",
        "metric": "tf-metric",
        "labels": {
            "foo": "bar",
        },
    })

    package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/alerting"
	"github.com/pulumiverse/pulumi-grafana/sdk/v2/go/grafana/oss"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		recordingruleFolder, err := oss.NewFolder(ctx, "recordingrule_folder", &oss.FolderArgs{
			Title: pulumi.String("Alert Rule Folder"),
		})
		if err != nil {
			return err
		}
		_, err = alerting.NewRecordingRuleV0Alpha1(ctx, "example", &alerting.RecordingRuleV0Alpha1Args{
			Metadata: &alerting.RecordingRuleV0Alpha1MetadataArgs{
				Uid:       pulumi.String("example-recording-rule"),
				FolderUid: recordingruleFolder.Uid,
			},
			Spec: &alerting.RecordingRuleV0Alpha1SpecArgs{
				Title: pulumi.String("Example Recording Rule"),
				Trigger: &alerting.RecordingRuleV0Alpha1SpecTriggerArgs{
					Interval: pulumi.String("1m"),
				},
				Paused: pulumi.Bool(true),
				Expressions: pulumi.Any(map[string]interface{}{
					"A": map[string]interface{}{
						"model": map[string]interface{}{
							"editorMode":    "code",
							"expr":          "count(up{})",
							"instant":       true,
							"intervalMs":    1000,
							"legendFormat":  "__auto",
							"maxDataPoints": 43200,
							"range":         false,
							"refId":         "A",
						},
						"datasourceUid": "ds_uid",
						"relativeTimeRange": map[string]interface{}{
							"from": "600s",
							"to":   "0s",
						},
						"queryType": "",
						"source":    true,
					},
				}),
				TargetDatasourceUid: pulumi.String("target_ds_uid"),
				Metric:              pulumi.String("tf-metric"),
				Labels: pulumi.StringMap{
					"foo": pulumi.String("bar"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Grafana = Pulumiverse.Grafana;

return await Deployment.RunAsync(() => 
{
    var recordingruleFolder = new Grafana.Oss.Folder("recordingrule_folder", new()
    {
        Title = "Alert Rule Folder",
    });

    var example = new Grafana.Alerting.RecordingRuleV0Alpha1("example", new()
    {
        Metadata = new Grafana.Alerting.Inputs.RecordingRuleV0Alpha1MetadataArgs
        {
            Uid = "example-recording-rule",
            FolderUid = recordingruleFolder.Uid,
        },
        Spec = new Grafana.Alerting.Inputs.RecordingRuleV0Alpha1SpecArgs
        {
            Title = "Example Recording Rule",
            Trigger = new Grafana.Alerting.Inputs.RecordingRuleV0Alpha1SpecTriggerArgs
            {
                Interval = "1m",
            },
            Paused = true,
            Expressions = new Dictionary<string, object?>
            {
                ["A"] = new Dictionary<string, object?>
                {
                    ["model"] = new Dictionary<string, object?>
                    {
                        ["editorMode"] = "code",
                        ["expr"] = "count(up{})",
                        ["instant"] = true,
                        ["intervalMs"] = 1000,
                        ["legendFormat"] = "__auto",
                        ["maxDataPoints"] = 43200,
                        ["range"] = false,
                        ["refId"] = "A",
                    },
                    ["datasourceUid"] = "ds_uid",
                    ["relativeTimeRange"] = new Dictionary<string, object?>
                    {
                        ["from"] = "600s",
                        ["to"] = "0s",
                    },
                    ["queryType"] = "",
                    ["source"] = true,
                },
            },
            TargetDatasourceUid = "target_ds_uid",
            Metric = "tf-metric",
            Labels = 
            {
                { "foo", "bar" },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.grafana.oss.Folder;
import com.pulumi.grafana.oss.FolderArgs;
import com.pulumi.grafana.alerting.RecordingRuleV0Alpha1;
import com.pulumi.grafana.alerting.RecordingRuleV0Alpha1Args;
import com.pulumi.grafana.alerting.inputs.RecordingRuleV0Alpha1MetadataArgs;
import com.pulumi.grafana.alerting.inputs.RecordingRuleV0Alpha1SpecArgs;
import com.pulumi.grafana.alerting.inputs.RecordingRuleV0Alpha1SpecTriggerArgs;
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 recordingruleFolder = new Folder("recordingruleFolder", FolderArgs.builder()
            .title("Alert Rule Folder")
            .build());

        var example = new RecordingRuleV0Alpha1("example", RecordingRuleV0Alpha1Args.builder()
            .metadata(RecordingRuleV0Alpha1MetadataArgs.builder()
                .uid("example-recording-rule")
                .folderUid(recordingruleFolder.uid())
                .build())
            .spec(RecordingRuleV0Alpha1SpecArgs.builder()
                .title("Example Recording Rule")
                .trigger(RecordingRuleV0Alpha1SpecTriggerArgs.builder()
                    .interval("1m")
                    .build())
                .paused(true)
                .expressions(Map.of("A", Map.ofEntries(
                    Map.entry("model", Map.ofEntries(
                        Map.entry("editorMode", "code"),
                        Map.entry("expr", "count(up{})"),
                        Map.entry("instant", true),
                        Map.entry("intervalMs", 1000),
                        Map.entry("legendFormat", "__auto"),
                        Map.entry("maxDataPoints", 43200),
                        Map.entry("range", false),
                        Map.entry("refId", "A")
                    )),
                    Map.entry("datasourceUid", "ds_uid"),
                    Map.entry("relativeTimeRange", Map.ofEntries(
                        Map.entry("from", "600s"),
                        Map.entry("to", "0s")
                    )),
                    Map.entry("queryType", ""),
                    Map.entry("source", true)
                )))
                .targetDatasourceUid("target_ds_uid")
                .metric("tf-metric")
                .labels(Map.of("foo", "bar"))
                .build())
            .build());

    }
}

    resources:
  recordingruleFolder:
    type: grafana:oss:Folder
    name: recordingrule_folder
    properties:
      title: Alert Rule Folder
  example:
    type: grafana:alerting:RecordingRuleV0Alpha1
    properties:
      metadata:
        uid: example-recording-rule
        folderUid: ${recordingruleFolder.uid}
      spec:
        title: Example Recording Rule
        trigger:
          interval: 1m
        paused: true
        expressions:
          A:
            model:
              editorMode: code
              expr: count(up{})
              instant: true
              intervalMs: 1000
              legendFormat: __auto
              maxDataPoints: 43200
              range: false
              refId: A
            datasourceUid: ds_uid
            relativeTimeRange:
              from: 600s
              to: 0s
            queryType: ""
            source: true
        targetDatasourceUid: target_ds_uid
        metric: tf-metric
        labels:
          foo: bar

    Create RecordingRuleV0Alpha1 Resource

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

    Constructor syntax

    new RecordingRuleV0Alpha1(name: string, args?: RecordingRuleV0Alpha1Args, opts?: CustomResourceOptions);
    @overload
def RecordingRuleV0Alpha1(resource_name: str,
                          args: Optional[RecordingRuleV0Alpha1Args] = None,
                          opts: Optional[ResourceOptions] = None)

@overload
def RecordingRuleV0Alpha1(resource_name: str,
                          opts: Optional[ResourceOptions] = None,
                          metadata: Optional[RecordingRuleV0Alpha1MetadataArgs] = None,
                          options: Optional[RecordingRuleV0Alpha1OptionsArgs] = None,
                          spec: Optional[RecordingRuleV0Alpha1SpecArgs] = None)
    func NewRecordingRuleV0Alpha1(ctx *Context, name string, args *RecordingRuleV0Alpha1Args, opts ...ResourceOption) (*RecordingRuleV0Alpha1, error)
    public RecordingRuleV0Alpha1(string name, RecordingRuleV0Alpha1Args? args = null, CustomResourceOptions? opts = null)
    public RecordingRuleV0Alpha1(String name, RecordingRuleV0Alpha1Args args)
public RecordingRuleV0Alpha1(String name, RecordingRuleV0Alpha1Args args, CustomResourceOptions options)

    type: grafana:alerting:RecordingRuleV0Alpha1
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 RecordingRuleV0Alpha1Args
    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 RecordingRuleV0Alpha1Args
    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 RecordingRuleV0Alpha1Args
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RecordingRuleV0Alpha1Args
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RecordingRuleV0Alpha1Args
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

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

    var recordingRuleV0Alpha1Resource = new Grafana.Alerting.RecordingRuleV0Alpha1("recordingRuleV0Alpha1Resource", new()
{
    Metadata = new Grafana.Alerting.Inputs.RecordingRuleV0Alpha1MetadataArgs
    {
        Uid = "string",
        Annotations = 
        {
            { "string", "string" },
        },
        FolderUid = "string",
        Url = "string",
        Uuid = "string",
        Version = "string",
    },
    Options = new Grafana.Alerting.Inputs.RecordingRuleV0Alpha1OptionsArgs
    {
        Overwrite = false,
    },
    Spec = new Grafana.Alerting.Inputs.RecordingRuleV0Alpha1SpecArgs
    {
        Expressions = "any",
        Metric = "string",
        TargetDatasourceUid = "string",
        Title = "string",
        Labels = 
        {
            { "string", "string" },
        },
        Paused = false,
        Trigger = new Grafana.Alerting.Inputs.RecordingRuleV0Alpha1SpecTriggerArgs
        {
            Interval = "string",
        },
    },
});

    example, err := alerting.NewRecordingRuleV0Alpha1(ctx, "recordingRuleV0Alpha1Resource", &alerting.RecordingRuleV0Alpha1Args{
	Metadata: &alerting.RecordingRuleV0Alpha1MetadataArgs{
		Uid: pulumi.String("string"),
		Annotations: pulumi.StringMap{
			"string": pulumi.String("string"),
		},
		FolderUid: pulumi.String("string"),
		Url:       pulumi.String("string"),
		Uuid:      pulumi.String("string"),
		Version:   pulumi.String("string"),
	},
	Options: &alerting.RecordingRuleV0Alpha1OptionsArgs{
		Overwrite: pulumi.Bool(false),
	},
	Spec: &alerting.RecordingRuleV0Alpha1SpecArgs{
		Expressions:         pulumi.Any("any"),
		Metric:              pulumi.String("string"),
		TargetDatasourceUid: pulumi.String("string"),
		Title:               pulumi.String("string"),
		Labels: pulumi.StringMap{
			"string": pulumi.String("string"),
		},
		Paused: pulumi.Bool(false),
		Trigger: &alerting.RecordingRuleV0Alpha1SpecTriggerArgs{
			Interval: pulumi.String("string"),
		},
	},
})

    var recordingRuleV0Alpha1Resource = new RecordingRuleV0Alpha1("recordingRuleV0Alpha1Resource", RecordingRuleV0Alpha1Args.builder()
    .metadata(RecordingRuleV0Alpha1MetadataArgs.builder()
        .uid("string")
        .annotations(Map.of("string", "string"))
        .folderUid("string")
        .url("string")
        .uuid("string")
        .version("string")
        .build())
    .options(RecordingRuleV0Alpha1OptionsArgs.builder()
        .overwrite(false)
        .build())
    .spec(RecordingRuleV0Alpha1SpecArgs.builder()
        .expressions("any")
        .metric("string")
        .targetDatasourceUid("string")
        .title("string")
        .labels(Map.of("string", "string"))
        .paused(false)
        .trigger(RecordingRuleV0Alpha1SpecTriggerArgs.builder()
            .interval("string")
            .build())
        .build())
    .build());

    recording_rule_v0_alpha1_resource = grafana.alerting.RecordingRuleV0Alpha1("recordingRuleV0Alpha1Resource",
    metadata={
        "uid": "string",
        "annotations": {
            "string": "string",
        },
        "folder_uid": "string",
        "url": "string",
        "uuid": "string",
        "version": "string",
    },
    options={
        "overwrite": False,
    },
    spec={
        "expressions": "any",
        "metric": "string",
        "target_datasource_uid": "string",
        "title": "string",
        "labels": {
            "string": "string",
        },
        "paused": False,
        "trigger": {
            "interval": "string",
        },
    })

    const recordingRuleV0Alpha1Resource = new grafana.alerting.RecordingRuleV0Alpha1("recordingRuleV0Alpha1Resource", {
    metadata: {
        uid: "string",
        annotations: {
            string: "string",
        },
        folderUid: "string",
        url: "string",
        uuid: "string",
        version: "string",
    },
    options: {
        overwrite: false,
    },
    spec: {
        expressions: "any",
        metric: "string",
        targetDatasourceUid: "string",
        title: "string",
        labels: {
            string: "string",
        },
        paused: false,
        trigger: {
            interval: "string",
        },
    },
});

    type: grafana:alerting:RecordingRuleV0Alpha1
properties:
    metadata:
        annotations:
            string: string
        folderUid: string
        uid: string
        url: string
        uuid: string
        version: string
    options:
        overwrite: false
    spec:
        expressions: any
        labels:
            string: string
        metric: string
        paused: false
        targetDatasourceUid: string
        title: string
        trigger:
            interval: string

    RecordingRuleV0Alpha1 Resource Properties

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

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The RecordingRuleV0Alpha1 resource accepts the following input properties:

    Metadata RecordingRuleV0Alpha1MetadataArgs
    The metadata of the resource.
    Options RecordingRuleV0Alpha1OptionsArgs
    Options for applying the resource.
    Spec RecordingRuleV0Alpha1SpecArgs
    The spec of the resource.
    metadata RecordingRuleV0Alpha1Metadata
    The metadata of the resource.
    options RecordingRuleV0Alpha1Options
    Options for applying the resource.
    spec RecordingRuleV0Alpha1Spec
    The spec of the resource.
    metadata RecordingRuleV0Alpha1Metadata
    The metadata of the resource.
    options RecordingRuleV0Alpha1Options
    Options for applying the resource.
    spec RecordingRuleV0Alpha1Spec
    The spec of the resource.
    metadata RecordingRuleV0Alpha1MetadataArgs
    The metadata of the resource.
    options RecordingRuleV0Alpha1OptionsArgs
    Options for applying the resource.
    spec RecordingRuleV0Alpha1SpecArgs
    The spec of the resource.
    metadata Property Map
    The metadata of the resource.
    options Property Map
    Options for applying the resource.
    spec Property Map
    The spec of the resource.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the RecordingRuleV0Alpha1 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 RecordingRuleV0Alpha1 Resource

    Get an existing RecordingRuleV0Alpha1 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?: RecordingRuleV0Alpha1State, opts?: CustomResourceOptions): RecordingRuleV0Alpha1
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        metadata: Optional[RecordingRuleV0Alpha1MetadataArgs] = None,
        options: Optional[RecordingRuleV0Alpha1OptionsArgs] = None,
        spec: Optional[RecordingRuleV0Alpha1SpecArgs] = None) -> RecordingRuleV0Alpha1
    func GetRecordingRuleV0Alpha1(ctx *Context, name string, id IDInput, state *RecordingRuleV0Alpha1State, opts ...ResourceOption) (*RecordingRuleV0Alpha1, error)
    public static RecordingRuleV0Alpha1 Get(string name, Input<string> id, RecordingRuleV0Alpha1State? state, CustomResourceOptions? opts = null)
    public static RecordingRuleV0Alpha1 get(String name, Output<String> id, RecordingRuleV0Alpha1State state, CustomResourceOptions options)
    resources:  _:    type: grafana:alerting:RecordingRuleV0Alpha1    get:      id: ${id}
    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:
    Metadata RecordingRuleV0Alpha1MetadataArgs
    The metadata of the resource.
    Options RecordingRuleV0Alpha1OptionsArgs
    Options for applying the resource.
    Spec RecordingRuleV0Alpha1SpecArgs
    The spec of the resource.
    metadata RecordingRuleV0Alpha1Metadata
    The metadata of the resource.
    options RecordingRuleV0Alpha1Options
    Options for applying the resource.
    spec RecordingRuleV0Alpha1Spec
    The spec of the resource.
    metadata RecordingRuleV0Alpha1Metadata
    The metadata of the resource.
    options RecordingRuleV0Alpha1Options
    Options for applying the resource.
    spec RecordingRuleV0Alpha1Spec
    The spec of the resource.
    metadata RecordingRuleV0Alpha1MetadataArgs
    The metadata of the resource.
    options RecordingRuleV0Alpha1OptionsArgs
    Options for applying the resource.
    spec RecordingRuleV0Alpha1SpecArgs
    The spec of the resource.
    metadata Property Map
    The metadata of the resource.
    options Property Map
    Options for applying the resource.
    spec Property Map
    The spec of the resource.

    Supporting Types

    RecordingRuleV0Alpha1Metadata, RecordingRuleV0Alpha1MetadataArgs

    Uid string
    The unique identifier of the resource.
    Annotations Dictionary<string, string>
    Annotations of the resource.
    FolderUid string
    The UID of the folder to save the resource in.
    Url string
    The full URL of the resource.
    Uuid string
    The globally unique identifier of a resource, used by the API for tracking.
    Version string
    The version of the resource.
    Uid string
    The unique identifier of the resource.
    Annotations map[string]string
    Annotations of the resource.
    FolderUid string
    The UID of the folder to save the resource in.
    Url string
    The full URL of the resource.
    Uuid string
    The globally unique identifier of a resource, used by the API for tracking.
    Version string
    The version of the resource.
    uid String
    The unique identifier of the resource.
    annotations Map<String,String>
    Annotations of the resource.
    folderUid String
    The UID of the folder to save the resource in.
    url String
    The full URL of the resource.
    uuid String
    The globally unique identifier of a resource, used by the API for tracking.
    version String
    The version of the resource.
    uid string
    The unique identifier of the resource.
    annotations {[key: string]: string}
    Annotations of the resource.
    folderUid string
    The UID of the folder to save the resource in.
    url string
    The full URL of the resource.
    uuid string
    The globally unique identifier of a resource, used by the API for tracking.
    version string
    The version of the resource.
    uid str
    The unique identifier of the resource.
    annotations Mapping[str, str]
    Annotations of the resource.
    folder_uid str
    The UID of the folder to save the resource in.
    url str
    The full URL of the resource.
    uuid str
    The globally unique identifier of a resource, used by the API for tracking.
    version str
    The version of the resource.
    uid String
    The unique identifier of the resource.
    annotations Map<String>
    Annotations of the resource.
    folderUid String
    The UID of the folder to save the resource in.
    url String
    The full URL of the resource.
    uuid String
    The globally unique identifier of a resource, used by the API for tracking.
    version String
    The version of the resource.

    RecordingRuleV0Alpha1Options, RecordingRuleV0Alpha1OptionsArgs

    Overwrite bool
    Set to true if you want to overwrite existing resource with newer version, same resource title in folder or same resource uid.
    Overwrite bool
    Set to true if you want to overwrite existing resource with newer version, same resource title in folder or same resource uid.
    overwrite Boolean
    Set to true if you want to overwrite existing resource with newer version, same resource title in folder or same resource uid.
    overwrite boolean
    Set to true if you want to overwrite existing resource with newer version, same resource title in folder or same resource uid.
    overwrite bool
    Set to true if you want to overwrite existing resource with newer version, same resource title in folder or same resource uid.
    overwrite Boolean
    Set to true if you want to overwrite existing resource with newer version, same resource title in folder or same resource uid.

    RecordingRuleV0Alpha1Spec, RecordingRuleV0Alpha1SpecArgs

    Expressions object
    A sequence of stages that describe the contents of the rule.
    Metric string
    The name of the metric to write to.
    TargetDatasourceUid string
    The UID of the datasource to write the metric to.
    Title string
    The title of the recording rule.
    Labels Dictionary<string, string>
    Key-value pairs to attach to the recorded metric.
    Paused bool
    Sets whether the recording rule should be paused or not.
    Trigger Pulumiverse.Grafana.Alerting.Inputs.RecordingRuleV0Alpha1SpecTrigger
    The trigger configuration for the recording rule.
    Expressions interface{}
    A sequence of stages that describe the contents of the rule.
    Metric string
    The name of the metric to write to.
    TargetDatasourceUid string
    The UID of the datasource to write the metric to.
    Title string
    The title of the recording rule.
    Labels map[string]string
    Key-value pairs to attach to the recorded metric.
    Paused bool
    Sets whether the recording rule should be paused or not.
    Trigger RecordingRuleV0Alpha1SpecTrigger
    The trigger configuration for the recording rule.
    expressions Object
    A sequence of stages that describe the contents of the rule.
    metric String
    The name of the metric to write to.
    targetDatasourceUid String
    The UID of the datasource to write the metric to.
    title String
    The title of the recording rule.
    labels Map<String,String>
    Key-value pairs to attach to the recorded metric.
    paused Boolean
    Sets whether the recording rule should be paused or not.
    trigger RecordingRuleV0Alpha1SpecTrigger
    The trigger configuration for the recording rule.
    expressions any
    A sequence of stages that describe the contents of the rule.
    metric string
    The name of the metric to write to.
    targetDatasourceUid string
    The UID of the datasource to write the metric to.
    title string
    The title of the recording rule.
    labels {[key: string]: string}
    Key-value pairs to attach to the recorded metric.
    paused boolean
    Sets whether the recording rule should be paused or not.
    trigger RecordingRuleV0Alpha1SpecTrigger
    The trigger configuration for the recording rule.
    expressions Any
    A sequence of stages that describe the contents of the rule.
    metric str
    The name of the metric to write to.
    target_datasource_uid str
    The UID of the datasource to write the metric to.
    title str
    The title of the recording rule.
    labels Mapping[str, str]
    Key-value pairs to attach to the recorded metric.
    paused bool
    Sets whether the recording rule should be paused or not.
    trigger RecordingRuleV0Alpha1SpecTrigger
    The trigger configuration for the recording rule.
    expressions Any
    A sequence of stages that describe the contents of the rule.
    metric String
    The name of the metric to write to.
    targetDatasourceUid String
    The UID of the datasource to write the metric to.
    title String
    The title of the recording rule.
    labels Map<String>
    Key-value pairs to attach to the recorded metric.
    paused Boolean
    Sets whether the recording rule should be paused or not.
    trigger Property Map
    The trigger configuration for the recording rule.

    RecordingRuleV0Alpha1SpecTrigger, RecordingRuleV0Alpha1SpecTriggerArgs

    Interval string
    The interval at which the recording rule should be evaluated.
    Interval string
    The interval at which the recording rule should be evaluated.
    interval String
    The interval at which the recording rule should be evaluated.
    interval string
    The interval at which the recording rule should be evaluated.
    interval str
    The interval at which the recording rule should be evaluated.
    interval String
    The interval at which the recording rule should be evaluated.

    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 v2.15.0 published on Wednesday, Nov 12, 2025 by pulumiverse
    Schema (JSON)
    pulumiverse/pulumi-grafana
      Meet Neo: Your AI Platform Teammate