MetricAlarm class

Provides a CloudWatch Metric Alarm resource.

Example Usage

Basic Usage

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

const foobar = new aws.cloudwatch.MetricAlarm("foobar", {
    name: "test-foobar5",
    comparisonOperator: "GreaterThanOrEqualToThreshold",
    evaluationPeriods: 2,
    metricName: "CPUUtilization",
    namespace: "AWS/EC2",
    period: 120,
    statistic: "Average",
    threshold: 80,
    alarmDescription: "This metric monitors ec2 cpu utilization",
    insufficientDataActions: [],
});
import pulumi
import pulumi_aws as aws

foobar = aws.cloudwatch.MetricAlarm("foobar",
    name="test-foobar5",
    comparison_operator="GreaterThanOrEqualToThreshold",
    evaluation_periods=2,
    metric_name="CPUUtilization",
    namespace="AWS/EC2",
    period=120,
    statistic="Average",
    threshold=float(80),
    alarm_description="This metric monitors ec2 cpu utilization",
    insufficient_data_actions=[])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var foobar = new Aws.CloudWatch.MetricAlarm("foobar", new()
    {
        Name = "test-foobar5",
        ComparisonOperator = "GreaterThanOrEqualToThreshold",
        EvaluationPeriods = 2,
        MetricName = "CPUUtilization",
        Namespace = "AWS/EC2",
        Period = 120,
        Statistic = "Average",
        Threshold = 80,
        AlarmDescription = "This metric monitors ec2 cpu utilization",
        InsufficientDataActions =  {},
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudwatch.NewMetricAlarm(ctx, "foobar", &cloudwatch.MetricAlarmArgs{
			Name:                    pulumi.String("test-foobar5"),
			ComparisonOperator:      pulumi.String("GreaterThanOrEqualToThreshold"),
			EvaluationPeriods:       pulumi.Int(2),
			MetricName:              pulumi.String("CPUUtilization"),
			Namespace:               pulumi.String("AWS/EC2"),
			Period:                  pulumi.Int(120),
			Statistic:               pulumi.String("Average"),
			Threshold:               pulumi.Float64(80),
			AlarmDescription:        pulumi.String("This metric monitors ec2 cpu utilization"),
			InsufficientDataActions: pulumi.Array{},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_cloudwatch_metricalarm" "foobar" {
  name                      = "test-foobar5"
  comparison_operator       = "GreaterThanOrEqualToThreshold"
  evaluation_periods        = 2
  metric_name               = "CPUUtilization"
  namespace                 = "AWS/EC2"
  period                    = 120
  statistic                 = "Average"
  threshold                 = 80
  alarm_description         = "This metric monitors ec2 cpu utilization"
  insufficient_data_actions = []
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 foobar = new MetricAlarm("foobar", MetricAlarmArgs.builder()
            .name("test-foobar5")
            .comparisonOperator("GreaterThanOrEqualToThreshold")
            .evaluationPeriods(2)
            .metricName("CPUUtilization")
            .namespace("AWS/EC2")
            .period(120)
            .statistic("Average")
            .threshold(80.0)
            .alarmDescription("This metric monitors ec2 cpu utilization")
            .insufficientDataActions()
            .build());

    }
}
resources:
  foobar:
    type: aws:cloudwatch:MetricAlarm
    properties:
      name: test-foobar5
      comparisonOperator: GreaterThanOrEqualToThreshold
      evaluationPeriods: 2
      metricName: CPUUtilization
      namespace: AWS/EC2
      period: 120
      statistic: Average
      threshold: 80
      alarmDescription: This metric monitors ec2 cpu utilization
      insufficientDataActions: []

With Scaling Policies

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

const bat = new aws.autoscaling.Policy("bat", {
    name: "foobar3-test",
    scalingAdjustment: 4,
    adjustmentType: "ChangeInCapacity",
    cooldown: 300,
    autoscalingGroupName: bar.name,
});
const batMetricAlarm = new aws.cloudwatch.MetricAlarm("bat", {
    name: "test-foobar5",
    comparisonOperator: "GreaterThanOrEqualToThreshold",
    evaluationPeriods: 2,
    metricName: "CPUUtilization",
    namespace: "AWS/EC2",
    period: 120,
    statistic: "Average",
    threshold: 80,
    dimensions: {
        AutoScalingGroupName: bar.name,
    },
    alarmDescription: "This metric monitors ec2 cpu utilization",
    alarmActions: [bat.arn],
});
import pulumi
import pulumi_aws as aws

bat = aws.autoscaling.Policy("bat",
    name="foobar3-test",
    scaling_adjustment=4,
    adjustment_type="ChangeInCapacity",
    cooldown=300,
    autoscaling_group_name=bar["name"])
bat_metric_alarm = aws.cloudwatch.MetricAlarm("bat",
    name="test-foobar5",
    comparison_operator="GreaterThanOrEqualToThreshold",
    evaluation_periods=2,
    metric_name="CPUUtilization",
    namespace="AWS/EC2",
    period=120,
    statistic="Average",
    threshold=float(80),
    dimensions={
        "AutoScalingGroupName": bar["name"],
    },
    alarm_description="This metric monitors ec2 cpu utilization",
    alarm_actions=[bat.arn])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var bat = new Aws.AutoScaling.Policy("bat", new()
    {
        Name = "foobar3-test",
        ScalingAdjustment = 4,
        AdjustmentType = "ChangeInCapacity",
        Cooldown = 300,
        AutoscalingGroupName = bar.Name,
    });

    var batMetricAlarm = new Aws.CloudWatch.MetricAlarm("bat", new()
    {
        Name = "test-foobar5",
        ComparisonOperator = "GreaterThanOrEqualToThreshold",
        EvaluationPeriods = 2,
        MetricName = "CPUUtilization",
        Namespace = "AWS/EC2",
        Period = 120,
        Statistic = "Average",
        Threshold = 80,
        Dimensions =
        {
            { "AutoScalingGroupName", bar.Name },
        },
        AlarmDescription = "This metric monitors ec2 cpu utilization",
        AlarmActions =
        {
            bat.Arn,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/autoscaling"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		bat, err := autoscaling.NewPolicy(ctx, "bat", &autoscaling.PolicyArgs{
			Name:                 pulumi.String("foobar3-test"),
			ScalingAdjustment:    pulumi.Int(4),
			AdjustmentType:       pulumi.String("ChangeInCapacity"),
			Cooldown:             pulumi.Int(300),
			AutoscalingGroupName: pulumi.Any(bar.Name),
		})
		if err != nil {
			return err
		}
		_, err = cloudwatch.NewMetricAlarm(ctx, "bat", &cloudwatch.MetricAlarmArgs{
			Name:               pulumi.String("test-foobar5"),
			ComparisonOperator: pulumi.String("GreaterThanOrEqualToThreshold"),
			EvaluationPeriods:  pulumi.Int(2),
			MetricName:         pulumi.String("CPUUtilization"),
			Namespace:          pulumi.String("AWS/EC2"),
			Period:             pulumi.Int(120),
			Statistic:          pulumi.String("Average"),
			Threshold:          pulumi.Float64(80),
			Dimensions: pulumi.StringMap{
				"AutoScalingGroupName": pulumi.Any(bar.Name),
			},
			AlarmDescription: pulumi.String("This metric monitors ec2 cpu utilization"),
			AlarmActions: pulumi.Array{
				bat.Arn,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_autoscaling_policy" "bat" {
  name                   = "foobar3-test"
  scaling_adjustment     = 4
  adjustment_type        = "ChangeInCapacity"
  cooldown               = 300
  autoscaling_group_name = bar.name
}
resource "aws_cloudwatch_metricalarm" "bat" {
  name                = "test-foobar5"
  comparison_operator = "GreaterThanOrEqualToThreshold"
  evaluation_periods  = 2
  metric_name         = "CPUUtilization"
  namespace           = "AWS/EC2"
  period              = 120
  statistic           = "Average"
  threshold           = 80
  dimensions = {
    "AutoScalingGroupName" = bar.name
  }
  alarm_description = "This metric monitors ec2 cpu utilization"
  alarm_actions     = [aws_autoscaling_policy.bat.arn]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.autoscaling.Policy;
import com.pulumi.aws.autoscaling.PolicyArgs;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 bat = new Policy("bat", PolicyArgs.builder()
            .name("foobar3-test")
            .scalingAdjustment(4)
            .adjustmentType("ChangeInCapacity")
            .cooldown(300)
            .autoscalingGroupName(bar.name())
            .build());

        var batMetricAlarm = new MetricAlarm("batMetricAlarm", MetricAlarmArgs.builder()
            .name("test-foobar5")
            .comparisonOperator("GreaterThanOrEqualToThreshold")
            .evaluationPeriods(2)
            .metricName("CPUUtilization")
            .namespace("AWS/EC2")
            .period(120)
            .statistic("Average")
            .threshold(80.0)
            .dimensions(Map.of("AutoScalingGroupName", bar.name()))
            .alarmDescription("This metric monitors ec2 cpu utilization")
            .alarmActions(bat.arn())
            .build());

    }
}
resources:
  bat:
    type: aws:autoscaling:Policy
    properties:
      name: foobar3-test
      scalingAdjustment: 4
      adjustmentType: ChangeInCapacity
      cooldown: 300
      autoscalingGroupName: ${bar.name}
  batMetricAlarm:
    type: aws:cloudwatch:MetricAlarm
    name: bat
    properties:
      name: test-foobar5
      comparisonOperator: GreaterThanOrEqualToThreshold
      evaluationPeriods: 2
      metricName: CPUUtilization
      namespace: AWS/EC2
      period: 120
      statistic: Average
      threshold: 80
      dimensions:
        AutoScalingGroupName: ${bar.name}
      alarmDescription: This metric monitors ec2 cpu utilization
      alarmActions:
        - ${bat.arn}

With a Metrics Math Expression

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

const foobar = new aws.cloudwatch.MetricAlarm("foobar", {
    metricQueries: [
        {
            id: "e1",
            expression: "m2/m1*100",
            label: "Error Rate",
            returnData: true,
        },
        {
            metric: {
                metricName: "RequestCount",
                namespace: "AWS/ApplicationELB",
                period: 120,
                stat: "Sum",
                unit: "Count",
                dimensions: {
                    LoadBalancer: "app/web",
                },
            },
            id: "m1",
        },
        {
            metric: {
                metricName: "HTTPCode_ELB_5XX_Count",
                namespace: "AWS/ApplicationELB",
                period: 120,
                stat: "Sum",
                unit: "Count",
                dimensions: {
                    LoadBalancer: "app/web",
                },
            },
            id: "m2",
        },
    ],
    name: "test-foobar",
    comparisonOperator: "GreaterThanOrEqualToThreshold",
    evaluationPeriods: 2,
    threshold: 10,
    alarmDescription: "Request error rate has exceeded 10%",
    insufficientDataActions: [],
});
import pulumi
import pulumi_aws as aws

foobar = aws.cloudwatch.MetricAlarm("foobar",
    metric_queries=[
        {
            "id": "e1",
            "expression": "m2/m1*100",
            "label": "Error Rate",
            "return_data": True,
        },
        {
            "metric": {
                "metric_name": "RequestCount",
                "namespace": "AWS/ApplicationELB",
                "period": 120,
                "stat": "Sum",
                "unit": "Count",
                "dimensions": {
                    "LoadBalancer": "app/web",
                },
            },
            "id": "m1",
        },
        {
            "metric": {
                "metric_name": "HTTPCode_ELB_5XX_Count",
                "namespace": "AWS/ApplicationELB",
                "period": 120,
                "stat": "Sum",
                "unit": "Count",
                "dimensions": {
                    "LoadBalancer": "app/web",
                },
            },
            "id": "m2",
        },
    ],
    name="test-foobar",
    comparison_operator="GreaterThanOrEqualToThreshold",
    evaluation_periods=2,
    threshold=float(10),
    alarm_description="Request error rate has exceeded 10%",
    insufficient_data_actions=[])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var foobar = new Aws.CloudWatch.MetricAlarm("foobar", new()
    {
        MetricQueries = new[]
        {
            new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryArgs
            {
                Id = "e1",
                Expression = "m2/m1*100",
                Label = "Error Rate",
                ReturnData = true,
            },
            new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryArgs
            {
                Metric = new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryMetricArgs
                {
                    MetricName = "RequestCount",
                    Namespace = "AWS/ApplicationELB",
                    Period = 120,
                    Stat = "Sum",
                    Unit = "Count",
                    Dimensions =
                    {
                        { "LoadBalancer", "app/web" },
                    },
                },
                Id = "m1",
            },
            new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryArgs
            {
                Metric = new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryMetricArgs
                {
                    MetricName = "HTTPCode_ELB_5XX_Count",
                    Namespace = "AWS/ApplicationELB",
                    Period = 120,
                    Stat = "Sum",
                    Unit = "Count",
                    Dimensions =
                    {
                        { "LoadBalancer", "app/web" },
                    },
                },
                Id = "m2",
            },
        },
        Name = "test-foobar",
        ComparisonOperator = "GreaterThanOrEqualToThreshold",
        EvaluationPeriods = 2,
        Threshold = 10,
        AlarmDescription = "Request error rate has exceeded 10%",
        InsufficientDataActions =  {},
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudwatch.NewMetricAlarm(ctx, "foobar", &cloudwatch.MetricAlarmArgs{
			MetricQueries: cloudwatch.MetricAlarmMetricQueryArray{
				&cloudwatch.MetricAlarmMetricQueryArgs{
					Id:         pulumi.String("e1"),
					Expression: pulumi.String("m2/m1*100"),
					Label:      pulumi.String("Error Rate"),
					ReturnData: pulumi.Bool(true),
				},
				&cloudwatch.MetricAlarmMetricQueryArgs{
					Metric: &cloudwatch.MetricAlarmMetricQueryMetricArgs{
						MetricName: pulumi.String("RequestCount"),
						Namespace:  pulumi.String("AWS/ApplicationELB"),
						Period:     pulumi.Int(120),
						Stat:       pulumi.String("Sum"),
						Unit:       pulumi.String("Count"),
						Dimensions: pulumi.StringMap{
							"LoadBalancer": pulumi.String("app/web"),
						},
					},
					Id: pulumi.String("m1"),
				},
				&cloudwatch.MetricAlarmMetricQueryArgs{
					Metric: &cloudwatch.MetricAlarmMetricQueryMetricArgs{
						MetricName: pulumi.String("HTTPCode_ELB_5XX_Count"),
						Namespace:  pulumi.String("AWS/ApplicationELB"),
						Period:     pulumi.Int(120),
						Stat:       pulumi.String("Sum"),
						Unit:       pulumi.String("Count"),
						Dimensions: pulumi.StringMap{
							"LoadBalancer": pulumi.String("app/web"),
						},
					},
					Id: pulumi.String("m2"),
				},
			},
			Name:                    pulumi.String("test-foobar"),
			ComparisonOperator:      pulumi.String("GreaterThanOrEqualToThreshold"),
			EvaluationPeriods:       pulumi.Int(2),
			Threshold:               pulumi.Float64(10),
			AlarmDescription:        pulumi.String("Request error rate has exceeded 10%"),
			InsufficientDataActions: pulumi.Array{},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_cloudwatch_metricalarm" "foobar" {
  metric_queries {
    id          = "e1"
    expression  = "m2/m1*100"
    label       = "Error Rate"
    return_data = "true"
  }
  metric_queries {
    metric = {
      metric_name = "RequestCount"
      namespace   = "AWS/ApplicationELB"
      period      = 120
      stat        = "Sum"
      unit        = "Count"
      dimensions = {
        "LoadBalancer" = "app/web"
      }
    }
    id = "m1"
  }
  metric_queries {
    metric = {
      metric_name = "HTTPCode_ELB_5XX_Count"
      namespace   = "AWS/ApplicationELB"
      period      = 120
      stat        = "Sum"
      unit        = "Count"
      dimensions = {
        "LoadBalancer" = "app/web"
      }
    }
    id = "m2"
  }
  name                      = "test-foobar"
  comparison_operator       = "GreaterThanOrEqualToThreshold"
  evaluation_periods        = 2
  threshold                 = 10
  alarm_description         = "Request error rate has exceeded 10%"
  insufficient_data_actions = []
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import com.pulumi.aws.cloudwatch.inputs.MetricAlarmMetricQueryArgs;
import com.pulumi.aws.cloudwatch.inputs.MetricAlarmMetricQueryMetricArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 foobar = new MetricAlarm("foobar", MetricAlarmArgs.builder()
            .metricQueries(
                MetricAlarmMetricQueryArgs.builder()
                    .id("e1")
                    .expression("m2/m1*100")
                    .label("Error Rate")
                    .returnData(true)
                    .build(),
                MetricAlarmMetricQueryArgs.builder()
                    .metric(MetricAlarmMetricQueryMetricArgs.builder()
                        .metricName("RequestCount")
                        .namespace("AWS/ApplicationELB")
                        .period(120)
                        .stat("Sum")
                        .unit("Count")
                        .dimensions(Map.of("LoadBalancer", "app/web"))
                        .build())
                    .id("m1")
                    .build(),
                MetricAlarmMetricQueryArgs.builder()
                    .metric(MetricAlarmMetricQueryMetricArgs.builder()
                        .metricName("HTTPCode_ELB_5XX_Count")
                        .namespace("AWS/ApplicationELB")
                        .period(120)
                        .stat("Sum")
                        .unit("Count")
                        .dimensions(Map.of("LoadBalancer", "app/web"))
                        .build())
                    .id("m2")
                    .build())
            .name("test-foobar")
            .comparisonOperator("GreaterThanOrEqualToThreshold")
            .evaluationPeriods(2)
            .threshold(10.0)
            .alarmDescription("Request error rate has exceeded 10%")
            .insufficientDataActions()
            .build());

    }
}
resources:
  foobar:
    type: aws:cloudwatch:MetricAlarm
    properties:
      metricQueries:
        - id: e1
          expression: m2/m1*100
          label: Error Rate
          returnData: 'true'
        - metric:
            metricName: RequestCount
            namespace: AWS/ApplicationELB
            period: 120
            stat: Sum
            unit: Count
            dimensions:
              LoadBalancer: app/web
          id: m1
        - metric:
            metricName: HTTPCode_ELB_5XX_Count
            namespace: AWS/ApplicationELB
            period: 120
            stat: Sum
            unit: Count
            dimensions:
              LoadBalancer: app/web
          id: m2
      name: test-foobar
      comparisonOperator: GreaterThanOrEqualToThreshold
      evaluationPeriods: 2
      threshold: 10
      alarmDescription: Request error rate has exceeded 10%
      insufficientDataActions: []

With PromQL

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

const promqlAlarm = new aws.cloudwatch.MetricAlarm("promql_alarm", {
    evaluationCriteria: {
        promqlCriteria: {
            query: "avg(cpu_utilization_percent) > 80",
            pendingPeriod: 300,
            recoveryPeriod: 120,
        },
    },
    name: "high-cpu-promql",
    alarmDescription: "Alarm when average CPU exceeds 80% using PromQL",
    evaluationInterval: 30,
    alarmActions: [alerts.arn],
});
import pulumi
import pulumi_aws as aws

promql_alarm = aws.cloudwatch.MetricAlarm("promql_alarm",
    evaluation_criteria={
        "promql_criteria": {
            "query": "avg(cpu_utilization_percent) > 80",
            "pending_period": 300,
            "recovery_period": 120,
        },
    },
    name="high-cpu-promql",
    alarm_description="Alarm when average CPU exceeds 80% using PromQL",
    evaluation_interval=30,
    alarm_actions=[alerts["arn"]])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var promqlAlarm = new Aws.CloudWatch.MetricAlarm("promql_alarm", new()
    {
        EvaluationCriteria = new Aws.CloudWatch.Inputs.MetricAlarmEvaluationCriteriaArgs
        {
            PromqlCriteria = new Aws.CloudWatch.Inputs.MetricAlarmEvaluationCriteriaPromqlCriteriaArgs
            {
                Query = "avg(cpu_utilization_percent) > 80",
                PendingPeriod = 300,
                RecoveryPeriod = 120,
            },
        },
        Name = "high-cpu-promql",
        AlarmDescription = "Alarm when average CPU exceeds 80% using PromQL",
        EvaluationInterval = 30,
        AlarmActions =
        {
            alerts.Arn,
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudwatch.NewMetricAlarm(ctx, "promql_alarm", &cloudwatch.MetricAlarmArgs{
			EvaluationCriteria: &cloudwatch.MetricAlarmEvaluationCriteriaArgs{
				PromqlCriteria: &cloudwatch.MetricAlarmEvaluationCriteriaPromqlCriteriaArgs{
					Query:          pulumi.String("avg(cpu_utilization_percent) > 80"),
					PendingPeriod:  pulumi.Int(300),
					RecoveryPeriod: pulumi.Int(120),
				},
			},
			Name:               pulumi.String("high-cpu-promql"),
			AlarmDescription:   pulumi.String("Alarm when average CPU exceeds 80% using PromQL"),
			EvaluationInterval: pulumi.Int(30),
			AlarmActions: pulumi.Array{
				alerts.Arn,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_cloudwatch_metricalarm" "promql_alarm" {
  evaluation_criteria = {
    promql_criteria = {
      query           = "avg(cpu_utilization_percent) > 80"
      pending_period  = 300
      recovery_period = 120
    }
  }
  # 5 minutes
  # 5 minutes
  # 2 minutes
  name                = "high-cpu-promql"
  alarm_description   = "Alarm when average CPU exceeds 80% using PromQL"
  evaluation_interval = 30 # seconds
  alarm_actions       = [alerts.arn]
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import com.pulumi.aws.cloudwatch.inputs.MetricAlarmEvaluationCriteriaArgs;
import com.pulumi.aws.cloudwatch.inputs.MetricAlarmEvaluationCriteriaPromqlCriteriaArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 promqlAlarm = new MetricAlarm("promqlAlarm", MetricAlarmArgs.builder()
            .evaluationCriteria(MetricAlarmEvaluationCriteriaArgs.builder()
                .promqlCriteria(MetricAlarmEvaluationCriteriaPromqlCriteriaArgs.builder()
                    .query("avg(cpu_utilization_percent) > 80")
                    .pendingPeriod(300)
                    .recoveryPeriod(120)
                    .build())
                .build())
            .name("high-cpu-promql")
            .alarmDescription("Alarm when average CPU exceeds 80% using PromQL")
            .evaluationInterval(30)
            .alarmActions(alerts.arn())
            .build());

    }
}
resources:
  promqlAlarm:
    type: aws:cloudwatch:MetricAlarm
    name: promql_alarm
    properties:
      evaluationCriteria:
        promqlCriteria:
          query: avg(cpu_utilization_percent) > 80
          pendingPeriod: 300
          recoveryPeriod: 120
      name: high-cpu-promql
      alarmDescription: Alarm when average CPU exceeds 80% using PromQL
      evaluationInterval: 30 # seconds
      alarmActions:
        - ${alerts.arn}
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const xxAnomalyDetection = new aws.cloudwatch.MetricAlarm("xx_anomaly_detection", {
    metricQueries: [
        {
            id: "e1",
            returnData: true,
            expression: "ANOMALY_DETECTION_BAND(m1)",
            label: "CPUUtilization (Expected)",
        },
        {
            metric: {
                metricName: "CPUUtilization",
                namespace: "AWS/EC2",
                period: 120,
                stat: "Average",
                unit: "Count",
                dimensions: {
                    InstanceId: "i-abc123",
                },
            },
            id: "m1",
            returnData: true,
        },
    ],
    name: "test-foobar",
    comparisonOperator: "GreaterThanUpperThreshold",
    evaluationPeriods: 2,
    thresholdMetricId: "e1",
    alarmDescription: "This metric monitors ec2 cpu utilization",
    insufficientDataActions: [],
});
import pulumi
import pulumi_aws as aws

xx_anomaly_detection = aws.cloudwatch.MetricAlarm("xx_anomaly_detection",
    metric_queries=[
        {
            "id": "e1",
            "return_data": True,
            "expression": "ANOMALY_DETECTION_BAND(m1)",
            "label": "CPUUtilization (Expected)",
        },
        {
            "metric": {
                "metric_name": "CPUUtilization",
                "namespace": "AWS/EC2",
                "period": 120,
                "stat": "Average",
                "unit": "Count",
                "dimensions": {
                    "InstanceId": "i-abc123",
                },
            },
            "id": "m1",
            "return_data": True,
        },
    ],
    name="test-foobar",
    comparison_operator="GreaterThanUpperThreshold",
    evaluation_periods=2,
    threshold_metric_id="e1",
    alarm_description="This metric monitors ec2 cpu utilization",
    insufficient_data_actions=[])
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var xxAnomalyDetection = new Aws.CloudWatch.MetricAlarm("xx_anomaly_detection", new()
    {
        MetricQueries = new[]
        {
            new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryArgs
            {
                Id = "e1",
                ReturnData = true,
                Expression = "ANOMALY_DETECTION_BAND(m1)",
                Label = "CPUUtilization (Expected)",
            },
            new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryArgs
            {
                Metric = new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryMetricArgs
                {
                    MetricName = "CPUUtilization",
                    Namespace = "AWS/EC2",
                    Period = 120,
                    Stat = "Average",
                    Unit = "Count",
                    Dimensions =
                    {
                        { "InstanceId", "i-abc123" },
                    },
                },
                Id = "m1",
                ReturnData = true,
            },
        },
        Name = "test-foobar",
        ComparisonOperator = "GreaterThanUpperThreshold",
        EvaluationPeriods = 2,
        ThresholdMetricId = "e1",
        AlarmDescription = "This metric monitors ec2 cpu utilization",
        InsufficientDataActions =  {},
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudwatch.NewMetricAlarm(ctx, "xx_anomaly_detection", &cloudwatch.MetricAlarmArgs{
			MetricQueries: cloudwatch.MetricAlarmMetricQueryArray{
				&cloudwatch.MetricAlarmMetricQueryArgs{
					Id:         pulumi.String("e1"),
					ReturnData: pulumi.Bool(true),
					Expression: pulumi.String("ANOMALY_DETECTION_BAND(m1)"),
					Label:      pulumi.String("CPUUtilization (Expected)"),
				},
				&cloudwatch.MetricAlarmMetricQueryArgs{
					Metric: &cloudwatch.MetricAlarmMetricQueryMetricArgs{
						MetricName: pulumi.String("CPUUtilization"),
						Namespace:  pulumi.String("AWS/EC2"),
						Period:     pulumi.Int(120),
						Stat:       pulumi.String("Average"),
						Unit:       pulumi.String("Count"),
						Dimensions: pulumi.StringMap{
							"InstanceId": pulumi.String("i-abc123"),
						},
					},
					Id:         pulumi.String("m1"),
					ReturnData: pulumi.Bool(true),
				},
			},
			Name:                    pulumi.String("test-foobar"),
			ComparisonOperator:      pulumi.String("GreaterThanUpperThreshold"),
			EvaluationPeriods:       pulumi.Int(2),
			ThresholdMetricId:       pulumi.String("e1"),
			AlarmDescription:        pulumi.String("This metric monitors ec2 cpu utilization"),
			InsufficientDataActions: pulumi.Array{},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_cloudwatch_metricalarm" "xx_anomaly_detection" {
  metric_queries {
    id          = "e1"
    return_data = true
    expression  = "ANOMALY_DETECTION_BAND(m1)"
    label       = "CPUUtilization (Expected)"
  }
  metric_queries {
    metric = {
      metric_name = "CPUUtilization"
      namespace   = "AWS/EC2"
      period      = 120
      stat        = "Average"
      unit        = "Count"
      dimensions = {
        "InstanceId" = "i-abc123"
      }
    }
    id          = "m1"
    return_data = true
  }
  name                      = "test-foobar"
  comparison_operator       = "GreaterThanUpperThreshold"
  evaluation_periods        = 2
  threshold_metric_id       = "e1"
  alarm_description         = "This metric monitors ec2 cpu utilization"
  insufficient_data_actions = []
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import com.pulumi.aws.cloudwatch.inputs.MetricAlarmMetricQueryArgs;
import com.pulumi.aws.cloudwatch.inputs.MetricAlarmMetricQueryMetricArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 xxAnomalyDetection = new MetricAlarm("xxAnomalyDetection", MetricAlarmArgs.builder()
            .metricQueries(
                MetricAlarmMetricQueryArgs.builder()
                    .id("e1")
                    .returnData(true)
                    .expression("ANOMALY_DETECTION_BAND(m1)")
                    .label("CPUUtilization (Expected)")
                    .build(),
                MetricAlarmMetricQueryArgs.builder()
                    .metric(MetricAlarmMetricQueryMetricArgs.builder()
                        .metricName("CPUUtilization")
                        .namespace("AWS/EC2")
                        .period(120)
                        .stat("Average")
                        .unit("Count")
                        .dimensions(Map.of("InstanceId", "i-abc123"))
                        .build())
                    .id("m1")
                    .returnData(true)
                    .build())
            .name("test-foobar")
            .comparisonOperator("GreaterThanUpperThreshold")
            .evaluationPeriods(2)
            .thresholdMetricId("e1")
            .alarmDescription("This metric monitors ec2 cpu utilization")
            .insufficientDataActions()
            .build());

    }
}
resources:
  xxAnomalyDetection:
    type: aws:cloudwatch:MetricAlarm
    name: xx_anomaly_detection
    properties:
      metricQueries:
        - id: e1
          returnData: true
          expression: ANOMALY_DETECTION_BAND(m1)
          label: CPUUtilization (Expected)
        - metric:
            metricName: CPUUtilization
            namespace: AWS/EC2
            period: 120
            stat: Average
            unit: Count
            dimensions:
              InstanceId: i-abc123
          id: m1
          returnData: true
      name: test-foobar
      comparisonOperator: GreaterThanUpperThreshold
      evaluationPeriods: 2
      thresholdMetricId: e1
      alarmDescription: This metric monitors ec2 cpu utilization
      insufficientDataActions: []

With a Metrics Insights Query

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

const example = new aws.cloudwatch.MetricAlarm("example", {
    metricQueries: [{
        id: "q1",
        expression: `SELECT
  MAX(DBLoadRelativeToNumVCPUs)
FROM SCHEMA(\\"AWS/RDS\\", DBInstanceIdentifier)
WHERE DBInstanceIdentifier != 'example-rds-instance'
GROUP BY DBInstanceIdentifier
ORDER BY MIN() ASC
LIMIT 1
`,
        period: 60,
        returnData: true,
        label: "Max DB Load of the Least-Loaded RDS Instance",
    }],
    name: "example-alarm",
    alarmDescription: "Triggers if the smallest per-instance maximum load during the evaluation period exceeds the threshold",
    comparisonOperator: "GreaterThanThreshold",
    evaluationPeriods: 1,
    threshold: 0.6,
    treatMissingData: "notBreaching",
});
import pulumi
import pulumi_aws as aws

example = aws.cloudwatch.MetricAlarm("example",
    metric_queries=[{
        "id": "q1",
        "expression": """SELECT
  MAX(DBLoadRelativeToNumVCPUs)
FROM SCHEMA(\"AWS/RDS\", DBInstanceIdentifier)
WHERE DBInstanceIdentifier != 'example-rds-instance'
GROUP BY DBInstanceIdentifier
ORDER BY MIN() ASC
LIMIT 1
""",
        "period": 60,
        "return_data": True,
        "label": "Max DB Load of the Least-Loaded RDS Instance",
    }],
    name="example-alarm",
    alarm_description="Triggers if the smallest per-instance maximum load during the evaluation period exceeds the threshold",
    comparison_operator="GreaterThanThreshold",
    evaluation_periods=1,
    threshold=0.6,
    treat_missing_data="notBreaching")
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.CloudWatch.MetricAlarm("example", new()
    {
        MetricQueries = new[]
        {
            new Aws.CloudWatch.Inputs.MetricAlarmMetricQueryArgs
            {
                Id = "q1",
                Expression = @"SELECT
  MAX(DBLoadRelativeToNumVCPUs)
FROM SCHEMA(\""AWS/RDS\"", DBInstanceIdentifier)
WHERE DBInstanceIdentifier != 'example-rds-instance'
GROUP BY DBInstanceIdentifier
ORDER BY MIN() ASC
LIMIT 1
",
                Period = 60,
                ReturnData = true,
                Label = "Max DB Load of the Least-Loaded RDS Instance",
            },
        },
        Name = "example-alarm",
        AlarmDescription = "Triggers if the smallest per-instance maximum load during the evaluation period exceeds the threshold",
        ComparisonOperator = "GreaterThanThreshold",
        EvaluationPeriods = 1,
        Threshold = 0.6,
        TreatMissingData = "notBreaching",
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudwatch.NewMetricAlarm(ctx, "example", &cloudwatch.MetricAlarmArgs{
			MetricQueries: cloudwatch.MetricAlarmMetricQueryArray{
				&cloudwatch.MetricAlarmMetricQueryArgs{
					Id: pulumi.String("q1"),
					Expression: pulumi.String(`SELECT
  MAX(DBLoadRelativeToNumVCPUs)
FROM SCHEMA(\"AWS/RDS\", DBInstanceIdentifier)
WHERE DBInstanceIdentifier != 'example-rds-instance'
GROUP BY DBInstanceIdentifier
ORDER BY MIN() ASC
LIMIT 1
`),
					Period:     pulumi.Int(60),
					ReturnData: pulumi.Bool(true),
					Label:      pulumi.String("Max DB Load of the Least-Loaded RDS Instance"),
				},
			},
			Name:               pulumi.String("example-alarm"),
			AlarmDescription:   pulumi.String("Triggers if the smallest per-instance maximum load during the evaluation period exceeds the threshold"),
			ComparisonOperator: pulumi.String("GreaterThanThreshold"),
			EvaluationPeriods:  pulumi.Int(1),
			Threshold:          pulumi.Float64(0.6),
			TreatMissingData:   pulumi.String("notBreaching"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_cloudwatch_metricalarm" "example" {
  metric_queries {
    id          = "q1"
    expression  = "SELECT\n  MAX(DBLoadRelativeToNumVCPUs)\nFROM SCHEMA(\\\"AWS/RDS\\\", DBInstanceIdentifier)\nWHERE DBInstanceIdentifier != 'example-rds-instance'\nGROUP BY DBInstanceIdentifier\nORDER BY MIN() ASC\nLIMIT 1\n"
    period      = 60
    return_data = true
    label       = "Max DB Load of the Least-Loaded RDS Instance"
  }
  name                = "example-alarm"
  alarm_description   = "Triggers if the smallest per-instance maximum load during the evaluation period exceeds the threshold"
  comparison_operator = "GreaterThanThreshold"
  evaluation_periods  = 1
  threshold           = 0.6
  treat_missing_data  = "notBreaching"
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import com.pulumi.aws.cloudwatch.inputs.MetricAlarmMetricQueryArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new MetricAlarm("example", MetricAlarmArgs.builder()
            .metricQueries(MetricAlarmMetricQueryArgs.builder()
                .id("q1")
                .expression("""
SELECT
  MAX(DBLoadRelativeToNumVCPUs)
FROM SCHEMA(\"AWS/RDS\", DBInstanceIdentifier)
WHERE DBInstanceIdentifier != 'example-rds-instance'
GROUP BY DBInstanceIdentifier
ORDER BY MIN() ASC
LIMIT 1
                """)
                .period(60)
                .returnData(true)
                .label("Max DB Load of the Least-Loaded RDS Instance")
                .build())
            .name("example-alarm")
            .alarmDescription("Triggers if the smallest per-instance maximum load during the evaluation period exceeds the threshold")
            .comparisonOperator("GreaterThanThreshold")
            .evaluationPeriods(1)
            .threshold(0.6)
            .treatMissingData("notBreaching")
            .build());

    }
}
resources:
  example:
    type: aws:cloudwatch:MetricAlarm
    properties:
      metricQueries:
        - id: q1
          expression: |
            SELECT
              MAX(DBLoadRelativeToNumVCPUs)
            FROM SCHEMA(\"AWS/RDS\", DBInstanceIdentifier)
            WHERE DBInstanceIdentifier != 'example-rds-instance'
            GROUP BY DBInstanceIdentifier
            ORDER BY MIN() ASC
            LIMIT 1
          period: 60
          returnData: true
          label: Max DB Load of the Least-Loaded RDS Instance
      name: example-alarm
      alarmDescription: Triggers if the smallest per-instance maximum load during the evaluation period exceeds the threshold
      comparisonOperator: GreaterThanThreshold
      evaluationPeriods: 1
      threshold: 0.6
      treatMissingData: notBreaching

Monitoring Healthy NLB Hosts with Target Group and NLB

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

const nlbHealthyhosts = new aws.cloudwatch.MetricAlarm("nlb_healthyhosts", {
    name: "alarmname",
    comparisonOperator: "LessThanThreshold",
    evaluationPeriods: 1,
    metricName: "HealthyHostCount",
    namespace: "AWS/NetworkELB",
    period: 60,
    statistic: "Average",
    threshold: logstashServersCount,
    alarmDescription: "Number of healthy nodes in Target Group",
    actionsEnabled: true,
    alarmActions: [sns.arn],
    okActions: [sns.arn],
    dimensions: {
        TargetGroup: lb_tg.arnSuffix,
        LoadBalancer: lb.arnSuffix,
    },
});
import pulumi
import pulumi_aws as aws

nlb_healthyhosts = aws.cloudwatch.MetricAlarm("nlb_healthyhosts",
    name="alarmname",
    comparison_operator="LessThanThreshold",
    evaluation_periods=1,
    metric_name="HealthyHostCount",
    namespace="AWS/NetworkELB",
    period=60,
    statistic="Average",
    threshold=logstash_servers_count,
    alarm_description="Number of healthy nodes in Target Group",
    actions_enabled=True,
    alarm_actions=[sns["arn"]],
    ok_actions=[sns["arn"]],
    dimensions={
        "TargetGroup": lb_tg["arnSuffix"],
        "LoadBalancer": lb["arnSuffix"],
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var nlbHealthyhosts = new Aws.CloudWatch.MetricAlarm("nlb_healthyhosts", new()
    {
        Name = "alarmname",
        ComparisonOperator = "LessThanThreshold",
        EvaluationPeriods = 1,
        MetricName = "HealthyHostCount",
        Namespace = "AWS/NetworkELB",
        Period = 60,
        Statistic = "Average",
        Threshold = logstashServersCount,
        AlarmDescription = "Number of healthy nodes in Target Group",
        ActionsEnabled = true,
        AlarmActions =
        {
            sns.Arn,
        },
        OkActions =
        {
            sns.Arn,
        },
        Dimensions =
        {
            { "TargetGroup", lb_tg.ArnSuffix },
            { "LoadBalancer", lb.ArnSuffix },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/cloudwatch"
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/sns"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudwatch.NewMetricAlarm(ctx, "nlb_healthyhosts", &cloudwatch.MetricAlarmArgs{
			Name:               pulumi.String("alarmname"),
			ComparisonOperator: pulumi.String("LessThanThreshold"),
			EvaluationPeriods:  pulumi.Int(1),
			MetricName:         pulumi.String("HealthyHostCount"),
			Namespace:          pulumi.String("AWS/NetworkELB"),
			Period:             pulumi.Int(60),
			Statistic:          pulumi.String("Average"),
			Threshold:          pulumi.Any(logstashServersCount),
			AlarmDescription:   pulumi.String("Number of healthy nodes in Target Group"),
			ActionsEnabled:     pulumi.Bool(true),
			AlarmActions: pulumi.Array{
				sns.Arn,
			},
			OkActions: pulumi.Array{
				sns.Arn,
			},
			Dimensions: pulumi.StringMap{
				"TargetGroup":  pulumi.Any(lb_tg.ArnSuffix),
				"LoadBalancer": pulumi.Any(lb.ArnSuffix),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_cloudwatch_metricalarm" "nlb_healthyhosts" {
  name                = "alarmname"
  comparison_operator = "LessThanThreshold"
  evaluation_periods  = 1
  metric_name         = "HealthyHostCount"
  namespace           = "AWS/NetworkELB"
  period              = 60
  statistic           = "Average"
  threshold           = logstashServersCount
  alarm_description   = "Number of healthy nodes in Target Group"
  actions_enabled     = "true"
  alarm_actions       = [sns.arn]
  ok_actions          = [sns.arn]
  dimensions = {
    "TargetGroup"  = lb-tg.arnSuffix
    "LoadBalancer" = lb.arnSuffix
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.cloudwatch.MetricAlarm;
import com.pulumi.aws.cloudwatch.MetricAlarmArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 nlbHealthyhosts = new MetricAlarm("nlbHealthyhosts", MetricAlarmArgs.builder()
            .name("alarmname")
            .comparisonOperator("LessThanThreshold")
            .evaluationPeriods(1)
            .metricName("HealthyHostCount")
            .namespace("AWS/NetworkELB")
            .period(60)
            .statistic("Average")
            .threshold(logstashServersCount)
            .alarmDescription("Number of healthy nodes in Target Group")
            .actionsEnabled(true)
            .alarmActions(sns.arn())
            .okActions(sns.arn())
            .dimensions(Map.ofEntries(
                Map.entry("TargetGroup", lb_tg.arnSuffix()),
                Map.entry("LoadBalancer", lb.arnSuffix())
            ))
            .build());

    }
}
resources:
  nlbHealthyhosts:
    type: aws:cloudwatch:MetricAlarm
    name: nlb_healthyhosts
    properties:
      name: alarmname
      comparisonOperator: LessThanThreshold
      evaluationPeriods: 1
      metricName: HealthyHostCount
      namespace: AWS/NetworkELB
      period: 60
      statistic: Average
      threshold: ${logstashServersCount}
      alarmDescription: Number of healthy nodes in Target Group
      actionsEnabled: 'true'
      alarmActions:
        - ${sns.arn}
      okActions:
        - ${sns.arn}
      dimensions:
        TargetGroup: ${["lb-tg"].arnSuffix}
        LoadBalancer: ${lb.arnSuffix}

> NOTE: You cannot create a metric alarm consisting of both statistic and extendedStatistic parameters. You must choose one or the other.

Import

Identity Schema

Required

  • alarmName (String) Name of the CloudWatch metric alarm.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import CloudWatch Metric Alarm using the alarmName. For example:

$ pulumi import aws:cloudwatch/metricAlarm:MetricAlarm example alarm-12345

Constructors

MetricAlarm(String name, {MetricAlarmArgs? args, CustomResourceOptions? options})
Creates a new MetricAlarm. name The Pulumi resource name. args Arguments used to configure this MetricAlarm. The set of arguments for MetricAlarm. options Resource options controlling this resource's behavior.
MetricAlarm.reference(String urn)
Creates a typed reference to an existing MetricAlarm resource.

Properties

actionsEnabled ↔ Output<bool?>
Indicates whether or not actions should be executed during any changes to the alarm's state. Defaults to true.
latefinal
alarmActions ↔ Output<List<String>?>
List of actions to execute when this alarm transitions into an ALARM state from any other state. Each action is specified as an ARN.
latefinal
alarmDescription ↔ Output<String?>
The description for the alarm.
latefinal
arn ↔ Output<String>
The ARN of the CloudWatch Metric Alarm.
latefinal
childResources → Set<Resource>
finalinherited
comparisonOperator ↔ Output<String?>
The arithmetic operation to use when comparing the specified Statistic and Threshold. The specified Statistic value is used as the first operand. Either of the following is supported: GreaterThanOrEqualToThreshold, GreaterThanThreshold, LessThanThreshold, LessThanOrEqualToThreshold. Additionally, the values LessThanLowerOrGreaterThanUpperThreshold, LessThanLowerThreshold, and GreaterThanUpperThreshold are used only for alarms based on anomaly detection models.
latefinal
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
datapointsToAlarm ↔ Output<int?>
The number of data points that must be breaching to trigger the alarm.
latefinal
dimensions ↔ Output<Map<String, String>?>
The dimensions for the alarm's associated metric. For the list of available dimensions see the AWS documentation here.
latefinal
evaluateLowSampleCountPercentiles ↔ Output<String>
Used only for alarms based on percentiles. If you specify ignore, the alarm state will not change during periods with too few data points to be statistically significant. If you specify evaluate or omit this parameter, the alarm will always be evaluated and possibly change state no matter how many data points are available. The following values are supported: ignore, and evaluate.
latefinal
evaluationCriteria ↔ Output<MetricAlarmEvaluationCriteria?>
The evaluation criteria for PromQL alarms. Cannot be used with traditional metric alarm parameters.
latefinal
evaluationInterval ↔ Output<int?>
The frequency, in seconds, at which the alarm is evaluated. Valid values are 10, 20, 30, and any multiple of 60. Required when using evaluationCriteria.
latefinal
evaluationPeriods ↔ Output<int?>
The number of periods over which data is compared to the specified threshold. Required for traditional metric alarms.
latefinal
extendedStatistic ↔ Output<String?>
The percentile statistic for the metric associated with the alarm. Specify a value between p0.0 and p100.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
insufficientDataActions ↔ Output<List<String>?>
List of actions to execute when this alarm transitions into an INSUFFICIENT_DATA state from any other state. Each action is specified as an ARN.
latefinal
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
metricName ↔ Output<String?>
The name for the alarm's associated metric. See docs for supported metrics.
latefinal
metricQueries ↔ Output<List<MetricAlarmMetricQuery>?>
Enables you to create an alarm based on a metric math expression. You may specify at most 20.
latefinal
name ↔ Output<String>
The descriptive name for the alarm. This name must be unique within the user's AWS account
latefinal
namespace ↔ Output<String?>
The namespace for the alarm's associated metric. See docs for the list of namespaces. See docs for supported metrics.
latefinal
okActions ↔ Output<List<String>?>
List of actions to execute when this alarm transitions into an OK state from any other state. Each action is specified as an ARN.
latefinal
period ↔ Output<int?>
The period in seconds over which the specified statistic is applied. Valid values are 10, 20, 30, or any multiple of 60.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
statistic ↔ Output<String?>
The statistic to apply to the alarm's associated metric. Either of the following is supported: SampleCount, Average, Sum, Minimum, Maximum
latefinal
tags ↔ Output<Map<String, String>?>
A map of tags to assign to the resource. .If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
A map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
threshold ↔ Output<double?>
The value against which the specified statistic is compared. This parameter is required for alarms based on static thresholds, but should not be used for alarms based on anomaly detection models.
latefinal
thresholdMetricId ↔ Output<String?>
If this is an alarm based on an anomaly detection model, make this value match the ID of the ANOMALY_DETECTION_BAND function.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
treatMissingData ↔ Output<String?>
Sets how this alarm is to handle missing data points. The following values are supported: missing, ignore, breaching and notBreaching. Defaults to missing.
latefinal
unit ↔ Output<String?>
The unit for the alarm's associated metric.
latefinal
urn ↔ Output<String>
latefinalinherited

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {MetricAlarmState? state, CustomResourceOptions? options}) → MetricAlarm
Gets an existing MetricAlarm resource's state with the given name and id.