volcengine.cloud_monitor.Rule

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

return await Deployment.RunAsync(() => 
{
    var foo = new Volcengine.Cloud_monitor.Rule("foo", new()
    {
        AlertMethods = new[]
        {
            "Email",
            "Webhook",
        },
        ConditionOperator = "||",
        Conditions = new[]
        {
            new Volcengine.Cloud_monitor.Inputs.RuleConditionArgs
            {
                ComparisonOperator = ">",
                MetricName = "DiskUsageAvail",
                MetricUnit = "Megabytes",
                Statistics = "avg",
                Threshold = "100",
            },
            new Volcengine.Cloud_monitor.Inputs.RuleConditionArgs
            {
                ComparisonOperator = ">",
                MetricName = "DiskUsageUtilization",
                MetricUnit = "Percent",
                Statistics = "avg",
                Threshold = "90",
            },
        },
        ContactGroupIds = new[]
        {
            "174284616403161****",
        },
        Description = "acc-test",
        EffectEndAt = "22:55",
        EffectStartAt = "00:15",
        EnableState = "disable",
        EvaluationCount = 5,
        Level = "warning",
        MultipleConditions = true,
        Namespace = "VCM_ECS",
        OriginalDimensions = new[]
        {
            new Volcengine.Cloud_monitor.Inputs.RuleOriginalDimensionArgs
            {
                Key = "ResourceID",
                Values = new[]
                {
                    "*",
                },
            },
            new Volcengine.Cloud_monitor.Inputs.RuleOriginalDimensionArgs
            {
                Key = "DiskName",
                Values = new[]
                {
                    "vda",
                    "vda1",
                },
            },
        },
        RecoveryNotify = new Volcengine.Cloud_monitor.Inputs.RuleRecoveryNotifyArgs
        {
            Enable = true,
        },
        Regions = "cn-beijing",
        RuleName = "acc-test-rule",
        SilenceTime = 5,
        SubNamespace = "Storage",
        WebHook = "http://alert.volc.com/callback",
    });

});

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/cloud_monitor"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloud_monitor.NewRule(ctx, "foo", &cloud_monitor.RuleArgs{
			AlertMethods: pulumi.StringArray{
				pulumi.String("Email"),
				pulumi.String("Webhook"),
			},
			ConditionOperator: pulumi.String("||"),
			Conditions: cloud_monitor.RuleConditionArray{
				&cloud_monitor.RuleConditionArgs{
					ComparisonOperator: pulumi.String(">"),
					MetricName:         pulumi.String("DiskUsageAvail"),
					MetricUnit:         pulumi.String("Megabytes"),
					Statistics:         pulumi.String("avg"),
					Threshold:          pulumi.String("100"),
				},
				&cloud_monitor.RuleConditionArgs{
					ComparisonOperator: pulumi.String(">"),
					MetricName:         pulumi.String("DiskUsageUtilization"),
					MetricUnit:         pulumi.String("Percent"),
					Statistics:         pulumi.String("avg"),
					Threshold:          pulumi.String("90"),
				},
			},
			ContactGroupIds: pulumi.StringArray{
				pulumi.String("174284616403161****"),
			},
			Description:        pulumi.String("acc-test"),
			EffectEndAt:        pulumi.String("22:55"),
			EffectStartAt:      pulumi.String("00:15"),
			EnableState:        pulumi.String("disable"),
			EvaluationCount:    pulumi.Int(5),
			Level:              pulumi.String("warning"),
			MultipleConditions: pulumi.Bool(true),
			Namespace:          pulumi.String("VCM_ECS"),
			OriginalDimensions: cloud_monitor.RuleOriginalDimensionArray{
				&cloud_monitor.RuleOriginalDimensionArgs{
					Key: pulumi.String("ResourceID"),
					Values: pulumi.StringArray{
						pulumi.String("*"),
					},
				},
				&cloud_monitor.RuleOriginalDimensionArgs{
					Key: pulumi.String("DiskName"),
					Values: pulumi.StringArray{
						pulumi.String("vda"),
						pulumi.String("vda1"),
					},
				},
			},
			RecoveryNotify: &cloud_monitor.RuleRecoveryNotifyArgs{
				Enable: pulumi.Bool(true),
			},
			Regions:      pulumi.String("cn-beijing"),
			RuleName:     pulumi.String("acc-test-rule"),
			SilenceTime:  pulumi.Int(5),
			SubNamespace: pulumi.String("Storage"),
			WebHook:      pulumi.String("http://alert.volc.com/callback"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.cloud_monitor.Rule;
import com.pulumi.volcengine.cloud_monitor.RuleArgs;
import com.pulumi.volcengine.cloud_monitor.inputs.RuleConditionArgs;
import com.pulumi.volcengine.cloud_monitor.inputs.RuleOriginalDimensionArgs;
import com.pulumi.volcengine.cloud_monitor.inputs.RuleRecoveryNotifyArgs;
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 foo = new Rule("foo", RuleArgs.builder()        
            .alertMethods(            
                "Email",
                "Webhook")
            .conditionOperator("||")
            .conditions(            
                RuleConditionArgs.builder()
                    .comparisonOperator(">")
                    .metricName("DiskUsageAvail")
                    .metricUnit("Megabytes")
                    .statistics("avg")
                    .threshold("100")
                    .build(),
                RuleConditionArgs.builder()
                    .comparisonOperator(">")
                    .metricName("DiskUsageUtilization")
                    .metricUnit("Percent")
                    .statistics("avg")
                    .threshold("90")
                    .build())
            .contactGroupIds("174284616403161****")
            .description("acc-test")
            .effectEndAt("22:55")
            .effectStartAt("00:15")
            .enableState("disable")
            .evaluationCount(5)
            .level("warning")
            .multipleConditions(true)
            .namespace("VCM_ECS")
            .originalDimensions(            
                RuleOriginalDimensionArgs.builder()
                    .key("ResourceID")
                    .values("*")
                    .build(),
                RuleOriginalDimensionArgs.builder()
                    .key("DiskName")
                    .values(                    
                        "vda",
                        "vda1")
                    .build())
            .recoveryNotify(RuleRecoveryNotifyArgs.builder()
                .enable(true)
                .build())
            .regions("cn-beijing")
            .ruleName("acc-test-rule")
            .silenceTime(5)
            .subNamespace("Storage")
            .webHook("http://alert.volc.com/callback")
            .build());

    }
}

import pulumi
import pulumi_volcengine as volcengine

foo = volcengine.cloud_monitor.Rule("foo",
    alert_methods=[
        "Email",
        "Webhook",
    ],
    condition_operator="||",
    conditions=[
        volcengine.cloud_monitor.RuleConditionArgs(
            comparison_operator=">",
            metric_name="DiskUsageAvail",
            metric_unit="Megabytes",
            statistics="avg",
            threshold="100",
        ),
        volcengine.cloud_monitor.RuleConditionArgs(
            comparison_operator=">",
            metric_name="DiskUsageUtilization",
            metric_unit="Percent",
            statistics="avg",
            threshold="90",
        ),
    ],
    contact_group_ids=["174284616403161****"],
    description="acc-test",
    effect_end_at="22:55",
    effect_start_at="00:15",
    enable_state="disable",
    evaluation_count=5,
    level="warning",
    multiple_conditions=True,
    namespace="VCM_ECS",
    original_dimensions=[
        volcengine.cloud_monitor.RuleOriginalDimensionArgs(
            key="ResourceID",
            values=["*"],
        ),
        volcengine.cloud_monitor.RuleOriginalDimensionArgs(
            key="DiskName",
            values=[
                "vda",
                "vda1",
            ],
        ),
    ],
    recovery_notify=volcengine.cloud_monitor.RuleRecoveryNotifyArgs(
        enable=True,
    ),
    regions="cn-beijing",
    rule_name="acc-test-rule",
    silence_time=5,
    sub_namespace="Storage",
    web_hook="http://alert.volc.com/callback")

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

const foo = new volcengine.cloud_monitor.Rule("foo", {
    alertMethods: [
        "Email",
        "Webhook",
    ],
    conditionOperator: "||",
    conditions: [
        {
            comparisonOperator: ">",
            metricName: "DiskUsageAvail",
            metricUnit: "Megabytes",
            statistics: "avg",
            threshold: "100",
        },
        {
            comparisonOperator: ">",
            metricName: "DiskUsageUtilization",
            metricUnit: "Percent",
            statistics: "avg",
            threshold: "90",
        },
    ],
    contactGroupIds: ["174284616403161****"],
    description: "acc-test",
    effectEndAt: "22:55",
    effectStartAt: "00:15",
    enableState: "disable",
    evaluationCount: 5,
    level: "warning",
    multipleConditions: true,
    namespace: "VCM_ECS",
    originalDimensions: [
        {
            key: "ResourceID",
            values: ["*"],
        },
        {
            key: "DiskName",
            values: [
                "vda",
                "vda1",
            ],
        },
    ],
    recoveryNotify: {
        enable: true,
    },
    regions: "cn-beijing",
    ruleName: "acc-test-rule",
    silenceTime: 5,
    subNamespace: "Storage",
    webHook: "http://alert.volc.com/callback",
});

resources:
  foo:
    type: volcengine:cloud_monitor:Rule
    properties:
      alertMethods:
        - Email
        - Webhook
      conditionOperator: '||'
      conditions:
        - comparisonOperator: '>'
          metricName: DiskUsageAvail
          metricUnit: Megabytes
          statistics: avg
          threshold: '100'
        - comparisonOperator: '>'
          metricName: DiskUsageUtilization
          metricUnit: Percent
          statistics: avg
          threshold: '90'
      contactGroupIds:
        - 174284616403161****
      description: acc-test
      effectEndAt: 22:55
      effectStartAt: 00:15
      enableState: disable
      evaluationCount: 5
      level: warning
      multipleConditions: true
      namespace: VCM_ECS
      originalDimensions:
        - key: ResourceID
          values:
            - '*'
        - key: DiskName
          values:
            - vda
            - vda1
      recoveryNotify:
        enable: true
      regions: cn-beijing
      ruleName: acc-test-rule
      silenceTime: 5
      subNamespace: Storage
      webHook: http://alert.volc.com/callback