1. Registry
  2. Packages
  3. AWS
  4. API Docs
  5. amp
  6. AnomalyDetector
Viewing docs for AWS v7.46.0
published on Thursday, Sep 10, 2026 by Pulumi
aws logo aws logo
Viewing docs for AWS v7.46.0
published on Thursday, Sep 10, 2026 by Pulumi

    Manages an AWS AMP (Managed Prometheus) Anomaly Detector.

    Example Usage

    Basic Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const example = new aws.amp.Workspace("example", {});
    const exampleAnomalyDetector = new aws.amp.AnomalyDetector("example", {
        configuration: {
            randomCutForest: {
                query: "avg(up)",
            },
        },
        missingDataAction: {
            skip: true,
        },
        alias: "example",
        workspaceId: example.id,
    });
    
    import pulumi
    import pulumi_aws as aws
    
    example = aws.amp.Workspace("example")
    example_anomaly_detector = aws.amp.AnomalyDetector("example",
        configuration={
            "random_cut_forest": {
                "query": "avg(up)",
            },
        },
        missing_data_action={
            "skip": True,
        },
        alias="example",
        workspace_id=example.id)
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amp"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		example, err := amp.NewWorkspace(ctx, "example", nil)
    		if err != nil {
    			return err
    		}
    		_, err = amp.NewAnomalyDetector(ctx, "example", &amp.AnomalyDetectorArgs{
    			Configuration: &amp.AnomalyDetectorConfigurationArgs{
    				RandomCutForest: &amp.AnomalyDetectorConfigurationRandomCutForestArgs{
    					Query: pulumi.String("avg(up)"),
    				},
    			},
    			MissingDataAction: &amp.AnomalyDetectorMissingDataActionArgs{
    				Skip: pulumi.Bool(true),
    			},
    			Alias:       pulumi.String("example"),
    			WorkspaceId: example.ID().ToIDOutput().ToStringOutput(),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var example = new Aws.Amp.Workspace("example");
    
        var exampleAnomalyDetector = new Aws.Amp.AnomalyDetector("example", new()
        {
            Configuration = new Aws.Amp.Inputs.AnomalyDetectorConfigurationArgs
            {
                RandomCutForest = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestArgs
                {
                    Query = "avg(up)",
                },
            },
            MissingDataAction = new Aws.Amp.Inputs.AnomalyDetectorMissingDataActionArgs
            {
                Skip = true,
            },
            Alias = "example",
            WorkspaceId = example.Id,
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.amp.Workspace;
    import com.pulumi.aws.amp.AnomalyDetector;
    import com.pulumi.aws.amp.AnomalyDetectorArgs;
    import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationArgs;
    import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationRandomCutForestArgs;
    import com.pulumi.aws.amp.inputs.AnomalyDetectorMissingDataActionArgs;
    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 Workspace("example");
    
            var exampleAnomalyDetector = new AnomalyDetector("exampleAnomalyDetector", AnomalyDetectorArgs.builder()
                .configuration(AnomalyDetectorConfigurationArgs.builder()
                    .randomCutForest(AnomalyDetectorConfigurationRandomCutForestArgs.builder()
                        .query("avg(up)")
                        .build())
                    .build())
                .missingDataAction(AnomalyDetectorMissingDataActionArgs.builder()
                    .skip(true)
                    .build())
                .alias("example")
                .workspaceId(example.id())
                .build());
    
        }
    }
    
    resources:
      example:
        type: aws:amp:Workspace
      exampleAnomalyDetector:
        type: aws:amp:AnomalyDetector
        name: example
        properties:
          configuration:
            randomCutForest:
              query: avg(up)
          missingDataAction:
            skip: true
          alias: example
          workspaceId: ${example.id}
    
    pulumi {
      required_providers {
        aws = {
          source = "pulumi/aws"
        }
      }
    }
    
    resource "aws_amp_workspace" "example" {
    }
    resource "aws_amp_anomalydetector" "example" {
      configuration = {
        random_cut_forest = {
          query = "avg(up)"
        }
      }
      missing_data_action = {
        skip = true
      }
      alias        = "example"
      workspace_id = aws_amp_workspace.example.id
    }
    

    With evaluation interval and labels

    import * as pulumi from "@pulumi/pulumi";
    import * as aws from "@pulumi/aws";
    
    const example = new aws.amp.Workspace("example", {});
    const exampleAnomalyDetector = new aws.amp.AnomalyDetector("example", {
        configuration: {
            randomCutForest: {
                ignoreNearExpectedFromAbove: {
                    ratio: 1.5,
                },
                ignoreNearExpectedFromBelow: {
                    amount: 2,
                },
                query: "avg(up)",
                sampleSize: 256,
                shingleSize: 4,
            },
        },
        missingDataAction: {
            markAsAnomaly: true,
        },
        alias: "example",
        workspaceId: example.id,
        evaluationIntervalInSeconds: 120,
        labels: {
            env: "production",
            team: "platform",
        },
    });
    
    import pulumi
    import pulumi_aws as aws
    
    example = aws.amp.Workspace("example")
    example_anomaly_detector = aws.amp.AnomalyDetector("example",
        configuration={
            "random_cut_forest": {
                "ignore_near_expected_from_above": {
                    "ratio": 1.5,
                },
                "ignore_near_expected_from_below": {
                    "amount": float(2),
                },
                "query": "avg(up)",
                "sample_size": 256,
                "shingle_size": 4,
            },
        },
        missing_data_action={
            "mark_as_anomaly": True,
        },
        alias="example",
        workspace_id=example.id,
        evaluation_interval_in_seconds=120,
        labels={
            "env": "production",
            "team": "platform",
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amp"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		example, err := amp.NewWorkspace(ctx, "example", nil)
    		if err != nil {
    			return err
    		}
    		_, err = amp.NewAnomalyDetector(ctx, "example", &amp.AnomalyDetectorArgs{
    			Configuration: &amp.AnomalyDetectorConfigurationArgs{
    				RandomCutForest: &amp.AnomalyDetectorConfigurationRandomCutForestArgs{
    					IgnoreNearExpectedFromAbove: &amp.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs{
    						Ratio: pulumi.Float64(1.5),
    					},
    					IgnoreNearExpectedFromBelow: &amp.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs{
    						Amount: pulumi.Float64(2),
    					},
    					Query:       pulumi.String("avg(up)"),
    					SampleSize:  pulumi.Int(256),
    					ShingleSize: pulumi.Int(4),
    				},
    			},
    			MissingDataAction: &amp.AnomalyDetectorMissingDataActionArgs{
    				MarkAsAnomaly: pulumi.Bool(true),
    			},
    			Alias:                       pulumi.String("example"),
    			WorkspaceId:                 example.ID().ToIDOutput().ToStringOutput(),
    			EvaluationIntervalInSeconds: pulumi.Int(120),
    			Labels: pulumi.StringMap{
    				"env":  pulumi.String("production"),
    				"team": pulumi.String("platform"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Aws = Pulumi.Aws;
    
    return await Deployment.RunAsync(() => 
    {
        var example = new Aws.Amp.Workspace("example");
    
        var exampleAnomalyDetector = new Aws.Amp.AnomalyDetector("example", new()
        {
            Configuration = new Aws.Amp.Inputs.AnomalyDetectorConfigurationArgs
            {
                RandomCutForest = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestArgs
                {
                    IgnoreNearExpectedFromAbove = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs
                    {
                        Ratio = 1.5,
                    },
                    IgnoreNearExpectedFromBelow = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs
                    {
                        Amount = 2,
                    },
                    Query = "avg(up)",
                    SampleSize = 256,
                    ShingleSize = 4,
                },
            },
            MissingDataAction = new Aws.Amp.Inputs.AnomalyDetectorMissingDataActionArgs
            {
                MarkAsAnomaly = true,
            },
            Alias = "example",
            WorkspaceId = example.Id,
            EvaluationIntervalInSeconds = 120,
            Labels = 
            {
                { "env", "production" },
                { "team", "platform" },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.aws.amp.Workspace;
    import com.pulumi.aws.amp.AnomalyDetector;
    import com.pulumi.aws.amp.AnomalyDetectorArgs;
    import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationArgs;
    import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationRandomCutForestArgs;
    import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs;
    import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs;
    import com.pulumi.aws.amp.inputs.AnomalyDetectorMissingDataActionArgs;
    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 Workspace("example");
    
            var exampleAnomalyDetector = new AnomalyDetector("exampleAnomalyDetector", AnomalyDetectorArgs.builder()
                .configuration(AnomalyDetectorConfigurationArgs.builder()
                    .randomCutForest(AnomalyDetectorConfigurationRandomCutForestArgs.builder()
                        .ignoreNearExpectedFromAbove(AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs.builder()
                            .ratio(1.5)
                            .build())
                        .ignoreNearExpectedFromBelow(AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs.builder()
                            .amount(2.0)
                            .build())
                        .query("avg(up)")
                        .sampleSize(256)
                        .shingleSize(4)
                        .build())
                    .build())
                .missingDataAction(AnomalyDetectorMissingDataActionArgs.builder()
                    .markAsAnomaly(true)
                    .build())
                .alias("example")
                .workspaceId(example.id())
                .evaluationIntervalInSeconds(120)
                .labels(Map.ofEntries(
                    Map.entry("env", "production"),
                    Map.entry("team", "platform")
                ))
                .build());
    
        }
    }
    
    resources:
      example:
        type: aws:amp:Workspace
      exampleAnomalyDetector:
        type: aws:amp:AnomalyDetector
        name: example
        properties:
          configuration:
            randomCutForest:
              ignoreNearExpectedFromAbove:
                ratio: 1.5
              ignoreNearExpectedFromBelow:
                amount: 2
              query: avg(up)
              sampleSize: 256
              shingleSize: 4
          missingDataAction:
            markAsAnomaly: true
          alias: example
          workspaceId: ${example.id}
          evaluationIntervalInSeconds: 120
          labels:
            env: production
            team: platform
    
    pulumi {
      required_providers {
        aws = {
          source = "pulumi/aws"
        }
      }
    }
    
    resource "aws_amp_workspace" "example" {
    }
    resource "aws_amp_anomalydetector" "example" {
      configuration = {
        random_cut_forest = {
          ignore_near_expected_from_above = {
            ratio = 1.5
          }
          ignore_near_expected_from_below = {
            amount = 2
          }
          query        = "avg(up)"
          sample_size  = 256
          shingle_size = 4
        }
      }
      missing_data_action = {
        mark_as_anomaly = true
      }
      alias                          = "example"
      workspace_id                   = aws_amp_workspace.example.id
      evaluation_interval_in_seconds = 120
      labels = {
        "env"  = "production"
        "team" = "platform"
      }
    }
    

    Create AnomalyDetector Resource

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

    Constructor syntax

    new AnomalyDetector(name: string, args: AnomalyDetectorArgs, opts?: CustomResourceOptions);
    @overload
    def AnomalyDetector(resource_name: str,
                        args: AnomalyDetectorArgs,
                        opts: Optional[ResourceOptions] = None)
    
    @overload
    def AnomalyDetector(resource_name: str,
                        opts: Optional[ResourceOptions] = None,
                        alias: Optional[str] = None,
                        configuration: Optional[AnomalyDetectorConfigurationArgs] = None,
                        missing_data_action: Optional[AnomalyDetectorMissingDataActionArgs] = None,
                        workspace_id: Optional[str] = None,
                        evaluation_interval_in_seconds: Optional[int] = None,
                        labels: Optional[Mapping[str, str]] = None,
                        region: Optional[str] = None,
                        tags: Optional[Mapping[str, str]] = None,
                        timeouts: Optional[AnomalyDetectorTimeoutsArgs] = None)
    func NewAnomalyDetector(ctx *Context, name string, args AnomalyDetectorArgs, opts ...ResourceOption) (*AnomalyDetector, error)
    public AnomalyDetector(string name, AnomalyDetectorArgs args, CustomResourceOptions? opts = null)
    public AnomalyDetector(String name, AnomalyDetectorArgs args)
    public AnomalyDetector(String name, AnomalyDetectorArgs args, CustomResourceOptions options)
    
    type: aws:amp:AnomalyDetector
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    resource "aws_amp_anomaly_detector" "name" {
        # resource properties
    }

    Parameters

    name string
    The unique name of the resource.
    args AnomalyDetectorArgs
    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 AnomalyDetectorArgs
    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 AnomalyDetectorArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args AnomalyDetectorArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args AnomalyDetectorArgs
    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 anomalyDetectorResource = new Aws.Amp.AnomalyDetector("anomalyDetectorResource", new()
    {
        Alias = "string",
        Configuration = new Aws.Amp.Inputs.AnomalyDetectorConfigurationArgs
        {
            RandomCutForest = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestArgs
            {
                Query = "string",
                IgnoreNearExpectedFromAbove = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs
                {
                    Amount = 0.0,
                    Ratio = 0.0,
                },
                IgnoreNearExpectedFromBelow = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs
                {
                    Amount = 0.0,
                    Ratio = 0.0,
                },
                SampleSize = 0,
                ShingleSize = 0,
            },
        },
        MissingDataAction = new Aws.Amp.Inputs.AnomalyDetectorMissingDataActionArgs
        {
            MarkAsAnomaly = false,
            Skip = false,
        },
        WorkspaceId = "string",
        EvaluationIntervalInSeconds = 0,
        Labels = 
        {
            { "string", "string" },
        },
        Region = "string",
        Tags = 
        {
            { "string", "string" },
        },
        Timeouts = new Aws.Amp.Inputs.AnomalyDetectorTimeoutsArgs
        {
            Create = "string",
            Delete = "string",
            Update = "string",
        },
    });
    
    example, err := amp.NewAnomalyDetector(ctx, "anomalyDetectorResource", &amp.AnomalyDetectorArgs{
    	Alias: pulumi.String("string"),
    	Configuration: &amp.AnomalyDetectorConfigurationArgs{
    		RandomCutForest: &amp.AnomalyDetectorConfigurationRandomCutForestArgs{
    			Query: pulumi.String("string"),
    			IgnoreNearExpectedFromAbove: &amp.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs{
    				Amount: pulumi.Float64(0),
    				Ratio:  pulumi.Float64(0),
    			},
    			IgnoreNearExpectedFromBelow: &amp.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs{
    				Amount: pulumi.Float64(0),
    				Ratio:  pulumi.Float64(0),
    			},
    			SampleSize:  pulumi.Int(0),
    			ShingleSize: pulumi.Int(0),
    		},
    	},
    	MissingDataAction: &amp.AnomalyDetectorMissingDataActionArgs{
    		MarkAsAnomaly: pulumi.Bool(false),
    		Skip:          pulumi.Bool(false),
    	},
    	WorkspaceId:                 pulumi.String("string"),
    	EvaluationIntervalInSeconds: pulumi.Int(0),
    	Labels: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	Region: pulumi.String("string"),
    	Tags: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	Timeouts: &amp.AnomalyDetectorTimeoutsArgs{
    		Create: pulumi.String("string"),
    		Delete: pulumi.String("string"),
    		Update: pulumi.String("string"),
    	},
    })
    
    resource "aws_amp_anomaly_detector" "anomalyDetectorResource" {
      lifecycle {
        create_before_destroy = true
      }
      alias = "string"
      configuration = {
        random_cut_forest = {
          query = "string"
          ignore_near_expected_from_above = {
            amount = 0
            ratio  = 0
          }
          ignore_near_expected_from_below = {
            amount = 0
            ratio  = 0
          }
          sample_size  = 0
          shingle_size = 0
        }
      }
      missing_data_action = {
        mark_as_anomaly = false
        skip            = false
      }
      workspace_id                   = "string"
      evaluation_interval_in_seconds = 0
      labels = {
        "string" = "string"
      }
      region = "string"
      tags = {
        "string" = "string"
      }
      timeouts = {
        create = "string"
        delete = "string"
        update = "string"
      }
    }
    
    var anomalyDetectorResource = new AnomalyDetector("anomalyDetectorResource", AnomalyDetectorArgs.builder()
        .alias("string")
        .configuration(AnomalyDetectorConfigurationArgs.builder()
            .randomCutForest(AnomalyDetectorConfigurationRandomCutForestArgs.builder()
                .query("string")
                .ignoreNearExpectedFromAbove(AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs.builder()
                    .amount(0.0)
                    .ratio(0.0)
                    .build())
                .ignoreNearExpectedFromBelow(AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs.builder()
                    .amount(0.0)
                    .ratio(0.0)
                    .build())
                .sampleSize(0)
                .shingleSize(0)
                .build())
            .build())
        .missingDataAction(AnomalyDetectorMissingDataActionArgs.builder()
            .markAsAnomaly(false)
            .skip(false)
            .build())
        .workspaceId("string")
        .evaluationIntervalInSeconds(0)
        .labels(Map.of("string", "string"))
        .region("string")
        .tags(Map.of("string", "string"))
        .timeouts(AnomalyDetectorTimeoutsArgs.builder()
            .create("string")
            .delete("string")
            .update("string")
            .build())
        .build());
    
    anomaly_detector_resource = aws.amp.AnomalyDetector("anomalyDetectorResource",
        alias="string",
        configuration={
            "random_cut_forest": {
                "query": "string",
                "ignore_near_expected_from_above": {
                    "amount": float(0),
                    "ratio": float(0),
                },
                "ignore_near_expected_from_below": {
                    "amount": float(0),
                    "ratio": float(0),
                },
                "sample_size": 0,
                "shingle_size": 0,
            },
        },
        missing_data_action={
            "mark_as_anomaly": False,
            "skip": False,
        },
        workspace_id="string",
        evaluation_interval_in_seconds=0,
        labels={
            "string": "string",
        },
        region="string",
        tags={
            "string": "string",
        },
        timeouts={
            "create": "string",
            "delete": "string",
            "update": "string",
        })
    
    const anomalyDetectorResource = new aws.amp.AnomalyDetector("anomalyDetectorResource", {
        alias: "string",
        configuration: {
            randomCutForest: {
                query: "string",
                ignoreNearExpectedFromAbove: {
                    amount: 0,
                    ratio: 0,
                },
                ignoreNearExpectedFromBelow: {
                    amount: 0,
                    ratio: 0,
                },
                sampleSize: 0,
                shingleSize: 0,
            },
        },
        missingDataAction: {
            markAsAnomaly: false,
            skip: false,
        },
        workspaceId: "string",
        evaluationIntervalInSeconds: 0,
        labels: {
            string: "string",
        },
        region: "string",
        tags: {
            string: "string",
        },
        timeouts: {
            create: "string",
            "delete": "string",
            update: "string",
        },
    });
    
    type: aws:amp:AnomalyDetector
    properties:
        alias: string
        configuration:
            randomCutForest:
                ignoreNearExpectedFromAbove:
                    amount: 0
                    ratio: 0
                ignoreNearExpectedFromBelow:
                    amount: 0
                    ratio: 0
                query: string
                sampleSize: 0
                shingleSize: 0
        evaluationIntervalInSeconds: 0
        labels:
            string: string
        missingDataAction:
            markAsAnomaly: false
            skip: false
        region: string
        tags:
            string: string
        timeouts:
            create: string
            delete: string
            update: string
        workspaceId: string
    

    AnomalyDetector 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 AnomalyDetector resource accepts the following input properties:

    Alias string
    Name of the anomaly detector.
    Configuration AnomalyDetectorConfiguration
    Configuration block for the anomaly detector algorithm. See configuration below.
    MissingDataAction AnomalyDetectorMissingDataAction
    Configuration block for the action to take when data is missing. See missingDataAction below.
    WorkspaceId string

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    EvaluationIntervalInSeconds int
    Interval in seconds at which the anomaly detector evaluates data.
    Labels Dictionary<string, string>
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    Region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Tags Dictionary<string, string>
    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.
    Timeouts AnomalyDetectorTimeouts
    Alias string
    Name of the anomaly detector.
    Configuration AnomalyDetectorConfigurationArgs
    Configuration block for the anomaly detector algorithm. See configuration below.
    MissingDataAction AnomalyDetectorMissingDataActionArgs
    Configuration block for the action to take when data is missing. See missingDataAction below.
    WorkspaceId string

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    EvaluationIntervalInSeconds int
    Interval in seconds at which the anomaly detector evaluates data.
    Labels map[string]string
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    Region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Tags map[string]string
    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.
    Timeouts AnomalyDetectorTimeoutsArgs
    alias string
    Name of the anomaly detector.
    configuration object
    Configuration block for the anomaly detector algorithm. See configuration below.
    missing_data_action object
    Configuration block for the action to take when data is missing. See missingDataAction below.
    workspace_id string

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    evaluation_interval_in_seconds number
    Interval in seconds at which the anomaly detector evaluates data.
    labels map(string)
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags map(string)
    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.
    timeouts object
    alias String
    Name of the anomaly detector.
    configuration AnomalyDetectorConfiguration
    Configuration block for the anomaly detector algorithm. See configuration below.
    missingDataAction AnomalyDetectorMissingDataAction
    Configuration block for the action to take when data is missing. See missingDataAction below.
    workspaceId String

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    evaluationIntervalInSeconds Integer
    Interval in seconds at which the anomaly detector evaluates data.
    labels Map<String,String>
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    region String
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags Map<String,String>
    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.
    timeouts AnomalyDetectorTimeouts
    alias string
    Name of the anomaly detector.
    configuration AnomalyDetectorConfiguration
    Configuration block for the anomaly detector algorithm. See configuration below.
    missingDataAction AnomalyDetectorMissingDataAction
    Configuration block for the action to take when data is missing. See missingDataAction below.
    workspaceId string

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    evaluationIntervalInSeconds number
    Interval in seconds at which the anomaly detector evaluates data.
    labels {[key: string]: string}
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags {[key: string]: string}
    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.
    timeouts AnomalyDetectorTimeouts
    alias str
    Name of the anomaly detector.
    configuration AnomalyDetectorConfigurationArgs
    Configuration block for the anomaly detector algorithm. See configuration below.
    missing_data_action AnomalyDetectorMissingDataActionArgs
    Configuration block for the action to take when data is missing. See missingDataAction below.
    workspace_id str

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    evaluation_interval_in_seconds int
    Interval in seconds at which the anomaly detector evaluates data.
    labels Mapping[str, str]
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    region str
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags Mapping[str, str]
    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.
    timeouts AnomalyDetectorTimeoutsArgs
    alias String
    Name of the anomaly detector.
    configuration Property Map
    Configuration block for the anomaly detector algorithm. See configuration below.
    missingDataAction Property Map
    Configuration block for the action to take when data is missing. See missingDataAction below.
    workspaceId String

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    evaluationIntervalInSeconds Number
    Interval in seconds at which the anomaly detector evaluates data.
    labels Map<String>
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    region String
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags Map<String>
    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.
    timeouts Property Map

    Outputs

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

    Arn string
    ARN of the Anomaly Detector.
    CreatedAt string
    RFC3339 timestamp of when the anomaly detector was created.
    Id string
    The provider-assigned unique ID for this managed resource.
    TagsAll Dictionary<string, string>
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    Arn string
    ARN of the Anomaly Detector.
    CreatedAt string
    RFC3339 timestamp of when the anomaly detector was created.
    Id string
    The provider-assigned unique ID for this managed resource.
    TagsAll map[string]string
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    arn string
    ARN of the Anomaly Detector.
    created_at string
    RFC3339 timestamp of when the anomaly detector was created.
    id string
    The provider-assigned unique ID for this managed resource.
    tags_all map(string)
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    arn String
    ARN of the Anomaly Detector.
    createdAt String
    RFC3339 timestamp of when the anomaly detector was created.
    id String
    The provider-assigned unique ID for this managed resource.
    tagsAll Map<String,String>
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    arn string
    ARN of the Anomaly Detector.
    createdAt string
    RFC3339 timestamp of when the anomaly detector was created.
    id string
    The provider-assigned unique ID for this managed resource.
    tagsAll {[key: string]: string}
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    arn str
    ARN of the Anomaly Detector.
    created_at str
    RFC3339 timestamp of when the anomaly detector was created.
    id str
    The provider-assigned unique ID for this managed resource.
    tags_all Mapping[str, str]
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    arn String
    ARN of the Anomaly Detector.
    createdAt String
    RFC3339 timestamp of when the anomaly detector was created.
    id String
    The provider-assigned unique ID for this managed resource.
    tagsAll Map<String>
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.

    Look up Existing AnomalyDetector Resource

    Get an existing AnomalyDetector 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?: AnomalyDetectorState, opts?: CustomResourceOptions): AnomalyDetector
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            alias: Optional[str] = None,
            arn: Optional[str] = None,
            configuration: Optional[AnomalyDetectorConfigurationArgs] = None,
            created_at: Optional[str] = None,
            evaluation_interval_in_seconds: Optional[int] = None,
            labels: Optional[Mapping[str, str]] = None,
            missing_data_action: Optional[AnomalyDetectorMissingDataActionArgs] = None,
            region: Optional[str] = None,
            tags: Optional[Mapping[str, str]] = None,
            tags_all: Optional[Mapping[str, str]] = None,
            timeouts: Optional[AnomalyDetectorTimeoutsArgs] = None,
            workspace_id: Optional[str] = None) -> AnomalyDetector
    func GetAnomalyDetector(ctx *Context, name string, id IDInput, state *AnomalyDetectorState, opts ...ResourceOption) (*AnomalyDetector, error)
    public static AnomalyDetector Get(string name, Input<string> id, AnomalyDetectorState? state, CustomResourceOptions? opts = null)
    public static AnomalyDetector get(String name, Output<String> id, AnomalyDetectorState state, CustomResourceOptions options)
    resources:  _:    type: aws:amp:AnomalyDetector    get:      id: ${id}
    import {
      to = aws_amp_anomaly_detector.example
      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:
    Alias string
    Name of the anomaly detector.
    Arn string
    ARN of the Anomaly Detector.
    Configuration AnomalyDetectorConfiguration
    Configuration block for the anomaly detector algorithm. See configuration below.
    CreatedAt string
    RFC3339 timestamp of when the anomaly detector was created.
    EvaluationIntervalInSeconds int
    Interval in seconds at which the anomaly detector evaluates data.
    Labels Dictionary<string, string>
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    MissingDataAction AnomalyDetectorMissingDataAction
    Configuration block for the action to take when data is missing. See missingDataAction below.
    Region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Tags Dictionary<string, string>
    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.
    TagsAll Dictionary<string, string>
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    Timeouts AnomalyDetectorTimeouts
    WorkspaceId string

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    Alias string
    Name of the anomaly detector.
    Arn string
    ARN of the Anomaly Detector.
    Configuration AnomalyDetectorConfigurationArgs
    Configuration block for the anomaly detector algorithm. See configuration below.
    CreatedAt string
    RFC3339 timestamp of when the anomaly detector was created.
    EvaluationIntervalInSeconds int
    Interval in seconds at which the anomaly detector evaluates data.
    Labels map[string]string
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    MissingDataAction AnomalyDetectorMissingDataActionArgs
    Configuration block for the action to take when data is missing. See missingDataAction below.
    Region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    Tags map[string]string
    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.
    TagsAll map[string]string
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    Timeouts AnomalyDetectorTimeoutsArgs
    WorkspaceId string

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    alias string
    Name of the anomaly detector.
    arn string
    ARN of the Anomaly Detector.
    configuration object
    Configuration block for the anomaly detector algorithm. See configuration below.
    created_at string
    RFC3339 timestamp of when the anomaly detector was created.
    evaluation_interval_in_seconds number
    Interval in seconds at which the anomaly detector evaluates data.
    labels map(string)
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    missing_data_action object
    Configuration block for the action to take when data is missing. See missingDataAction below.
    region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags map(string)
    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.
    tags_all map(string)
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    timeouts object
    workspace_id string

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    alias String
    Name of the anomaly detector.
    arn String
    ARN of the Anomaly Detector.
    configuration AnomalyDetectorConfiguration
    Configuration block for the anomaly detector algorithm. See configuration below.
    createdAt String
    RFC3339 timestamp of when the anomaly detector was created.
    evaluationIntervalInSeconds Integer
    Interval in seconds at which the anomaly detector evaluates data.
    labels Map<String,String>
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    missingDataAction AnomalyDetectorMissingDataAction
    Configuration block for the action to take when data is missing. See missingDataAction below.
    region String
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags Map<String,String>
    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.
    tagsAll Map<String,String>
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    timeouts AnomalyDetectorTimeouts
    workspaceId String

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    alias string
    Name of the anomaly detector.
    arn string
    ARN of the Anomaly Detector.
    configuration AnomalyDetectorConfiguration
    Configuration block for the anomaly detector algorithm. See configuration below.
    createdAt string
    RFC3339 timestamp of when the anomaly detector was created.
    evaluationIntervalInSeconds number
    Interval in seconds at which the anomaly detector evaluates data.
    labels {[key: string]: string}
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    missingDataAction AnomalyDetectorMissingDataAction
    Configuration block for the action to take when data is missing. See missingDataAction below.
    region string
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags {[key: string]: string}
    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.
    tagsAll {[key: string]: string}
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    timeouts AnomalyDetectorTimeouts
    workspaceId string

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    alias str
    Name of the anomaly detector.
    arn str
    ARN of the Anomaly Detector.
    configuration AnomalyDetectorConfigurationArgs
    Configuration block for the anomaly detector algorithm. See configuration below.
    created_at str
    RFC3339 timestamp of when the anomaly detector was created.
    evaluation_interval_in_seconds int
    Interval in seconds at which the anomaly detector evaluates data.
    labels Mapping[str, str]
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    missing_data_action AnomalyDetectorMissingDataActionArgs
    Configuration block for the action to take when data is missing. See missingDataAction below.
    region str
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags Mapping[str, str]
    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.
    tags_all Mapping[str, str]
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    timeouts AnomalyDetectorTimeoutsArgs
    workspace_id str

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    alias String
    Name of the anomaly detector.
    arn String
    ARN of the Anomaly Detector.
    configuration Property Map
    Configuration block for the anomaly detector algorithm. See configuration below.
    createdAt String
    RFC3339 timestamp of when the anomaly detector was created.
    evaluationIntervalInSeconds Number
    Interval in seconds at which the anomaly detector evaluates data.
    labels Map<String>
    Map of label key-value pairs used to scope the anomaly detector to specific time series.
    missingDataAction Property Map
    Configuration block for the action to take when data is missing. See missingDataAction below.
    region String
    Region where this resource will be managed. Defaults to the Region set in the provider configuration.
    tags Map<String>
    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.
    tagsAll Map<String>
    Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
    timeouts Property Map
    workspaceId String

    ID of the AMP workspace in which to create the anomaly detector.

    The following arguments are optional:

    Supporting Types

    AnomalyDetectorConfiguration, AnomalyDetectorConfigurationArgs

    RandomCutForest AnomalyDetectorConfigurationRandomCutForest
    Configuration block for the Random Cut Forest anomaly detection algorithm. See randomCutForest below.
    RandomCutForest AnomalyDetectorConfigurationRandomCutForest
    Configuration block for the Random Cut Forest anomaly detection algorithm. See randomCutForest below.
    random_cut_forest object
    Configuration block for the Random Cut Forest anomaly detection algorithm. See randomCutForest below.
    randomCutForest AnomalyDetectorConfigurationRandomCutForest
    Configuration block for the Random Cut Forest anomaly detection algorithm. See randomCutForest below.
    randomCutForest AnomalyDetectorConfigurationRandomCutForest
    Configuration block for the Random Cut Forest anomaly detection algorithm. See randomCutForest below.
    random_cut_forest AnomalyDetectorConfigurationRandomCutForest
    Configuration block for the Random Cut Forest anomaly detection algorithm. See randomCutForest below.
    randomCutForest Property Map
    Configuration block for the Random Cut Forest anomaly detection algorithm. See randomCutForest below.

    AnomalyDetectorConfigurationRandomCutForest, AnomalyDetectorConfigurationRandomCutForestArgs

    Query string
    PromQL query used to select the time series for anomaly detection.
    IgnoreNearExpectedFromAbove AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAbove
    Configuration block for suppressing anomalies when the observed value is slightly above the expected value. See ignoreNearExpectedFromAbove below.
    IgnoreNearExpectedFromBelow AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelow
    Configuration block for suppressing anomalies when the observed value is slightly below the expected value. See ignoreNearExpectedFromBelow below.
    SampleSize int
    Number of data points used to train the model. Must be at least 256.
    ShingleSize int
    Number of consecutive data points that form a single input to the model. Must be at least 2.
    Query string
    PromQL query used to select the time series for anomaly detection.
    IgnoreNearExpectedFromAbove AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAbove
    Configuration block for suppressing anomalies when the observed value is slightly above the expected value. See ignoreNearExpectedFromAbove below.
    IgnoreNearExpectedFromBelow AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelow
    Configuration block for suppressing anomalies when the observed value is slightly below the expected value. See ignoreNearExpectedFromBelow below.
    SampleSize int
    Number of data points used to train the model. Must be at least 256.
    ShingleSize int
    Number of consecutive data points that form a single input to the model. Must be at least 2.
    query string
    PromQL query used to select the time series for anomaly detection.
    ignore_near_expected_from_above object
    Configuration block for suppressing anomalies when the observed value is slightly above the expected value. See ignoreNearExpectedFromAbove below.
    ignore_near_expected_from_below object
    Configuration block for suppressing anomalies when the observed value is slightly below the expected value. See ignoreNearExpectedFromBelow below.
    sample_size number
    Number of data points used to train the model. Must be at least 256.
    shingle_size number
    Number of consecutive data points that form a single input to the model. Must be at least 2.
    query String
    PromQL query used to select the time series for anomaly detection.
    ignoreNearExpectedFromAbove AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAbove
    Configuration block for suppressing anomalies when the observed value is slightly above the expected value. See ignoreNearExpectedFromAbove below.
    ignoreNearExpectedFromBelow AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelow
    Configuration block for suppressing anomalies when the observed value is slightly below the expected value. See ignoreNearExpectedFromBelow below.
    sampleSize Integer
    Number of data points used to train the model. Must be at least 256.
    shingleSize Integer
    Number of consecutive data points that form a single input to the model. Must be at least 2.
    query string
    PromQL query used to select the time series for anomaly detection.
    ignoreNearExpectedFromAbove AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAbove
    Configuration block for suppressing anomalies when the observed value is slightly above the expected value. See ignoreNearExpectedFromAbove below.
    ignoreNearExpectedFromBelow AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelow
    Configuration block for suppressing anomalies when the observed value is slightly below the expected value. See ignoreNearExpectedFromBelow below.
    sampleSize number
    Number of data points used to train the model. Must be at least 256.
    shingleSize number
    Number of consecutive data points that form a single input to the model. Must be at least 2.
    query str
    PromQL query used to select the time series for anomaly detection.
    ignore_near_expected_from_above AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAbove
    Configuration block for suppressing anomalies when the observed value is slightly above the expected value. See ignoreNearExpectedFromAbove below.
    ignore_near_expected_from_below AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelow
    Configuration block for suppressing anomalies when the observed value is slightly below the expected value. See ignoreNearExpectedFromBelow below.
    sample_size int
    Number of data points used to train the model. Must be at least 256.
    shingle_size int
    Number of consecutive data points that form a single input to the model. Must be at least 2.
    query String
    PromQL query used to select the time series for anomaly detection.
    ignoreNearExpectedFromAbove Property Map
    Configuration block for suppressing anomalies when the observed value is slightly above the expected value. See ignoreNearExpectedFromAbove below.
    ignoreNearExpectedFromBelow Property Map
    Configuration block for suppressing anomalies when the observed value is slightly below the expected value. See ignoreNearExpectedFromBelow below.
    sampleSize Number
    Number of data points used to train the model. Must be at least 256.
    shingleSize Number
    Number of consecutive data points that form a single input to the model. Must be at least 2.

    AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAbove, AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs

    Amount double
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    Ratio double
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    Amount float64
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    Ratio float64
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount number
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio number
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount Double
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio Double
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount number
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio number
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount float
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio float
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount Number
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio Number
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.

    AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelow, AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs

    Amount double
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    Ratio double
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    Amount float64
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    Ratio float64
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount number
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio number
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount Double
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio Double
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount number
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio number
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount float
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio float
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.
    amount Number
    Absolute amount by which the observed value may exceed the expected value before being reported as an anomaly. Conflicts with ratio.
    ratio Number
    Ratio by which the observed value may exceed the expected value before being reported as an anomaly. Must be at least 0. Conflicts with amount.

    AnomalyDetectorMissingDataAction, AnomalyDetectorMissingDataActionArgs

    MarkAsAnomaly bool
    Whether to treat missing data points as anomalies. Must be set to true. Conflicts with skip.
    Skip bool
    Whether to skip missing data points without reporting them as anomalies. Must be set to true. Conflicts with markAsAnomaly.
    MarkAsAnomaly bool
    Whether to treat missing data points as anomalies. Must be set to true. Conflicts with skip.
    Skip bool
    Whether to skip missing data points without reporting them as anomalies. Must be set to true. Conflicts with markAsAnomaly.
    mark_as_anomaly bool
    Whether to treat missing data points as anomalies. Must be set to true. Conflicts with skip.
    skip bool
    Whether to skip missing data points without reporting them as anomalies. Must be set to true. Conflicts with markAsAnomaly.
    markAsAnomaly Boolean
    Whether to treat missing data points as anomalies. Must be set to true. Conflicts with skip.
    skip Boolean
    Whether to skip missing data points without reporting them as anomalies. Must be set to true. Conflicts with markAsAnomaly.
    markAsAnomaly boolean
    Whether to treat missing data points as anomalies. Must be set to true. Conflicts with skip.
    skip boolean
    Whether to skip missing data points without reporting them as anomalies. Must be set to true. Conflicts with markAsAnomaly.
    mark_as_anomaly bool
    Whether to treat missing data points as anomalies. Must be set to true. Conflicts with skip.
    skip bool
    Whether to skip missing data points without reporting them as anomalies. Must be set to true. Conflicts with markAsAnomaly.
    markAsAnomaly Boolean
    Whether to treat missing data points as anomalies. Must be set to true. Conflicts with skip.
    skip Boolean
    Whether to skip missing data points without reporting them as anomalies. Must be set to true. Conflicts with markAsAnomaly.

    AnomalyDetectorTimeouts, AnomalyDetectorTimeoutsArgs

    Create string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    Delete string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    Update string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    Create string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    Delete string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    Update string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update string
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create str
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete str
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update str
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    create String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
    delete String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
    update String
    A string that can be parsed as a duration consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).

    Import

    Identity Schema

    Required

    • id - (String) ID of the Anomaly Detector.
    • workspaceId - (String) ID of the AMP workspace containing the Anomaly Detector.

    Optional

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

    Using pulumi import, import AMP (Managed Prometheus) Anomaly Detector using a comma-delimited string combining id and workspaceId. For example:

    $ pulumi import aws:amp/anomalyDetector:AnomalyDetector example ad-12345678-abcd-1234-abcd-123456789012,ws-12345678-abcd-1234-abcd-123456789012
    

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

    Package Details

    Repository
    AWS Classic pulumi/pulumi-aws
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the aws Terraform Provider.
    aws logo aws logo
    Viewing docs for AWS v7.46.0
    published on Thursday, Sep 10, 2026 by Pulumi

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial