alicloud.sls.getAlerts

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

const config = new pulumi.Config();
const name = config.get("name") || "terraform-example";
const alertName = config.get("alertName") || "openapi-terraform-alert";
const projectName = config.get("projectName") || "terraform-alert-example";
const defaultINsMgl = new alicloud.log.Project("defaultINsMgl", {
    description: "terraform-alert-example",
    name: "terraform-alert-example",
});
const defaultAlert = new alicloud.sls.Alert("default", {
    configuration: {
        type: "tpl",
        version: "2",
        queryLists: [
            {
                query: "* | select *",
                timeSpanType: "Relative",
                start: "-15m",
                end: "now",
                storeType: "log",
                project: defaultINsMgl.id,
                store: "alert",
                region: "cn-beijing",
                powerSqlMode: "disable",
                chartTitle: "wkb-chart",
                dashboardId: "wkb-dashboard",
                ui: "{}",
                roleArn: "acs:ram::1654218965343050:role/aliyunslsalertmonitorrole",
            },
            {
                storeType: "meta",
                store: "user.rds_ip_whitelist",
            },
            {
                storeType: "meta",
                store: "myexample1",
            },
        ],
        groupConfiguration: {
            type: "no_group",
            fields: [
                "a",
                "b",
            ],
        },
        joinConfigurations: [
            {
                type: "no_join",
                condition: "aa",
            },
            {
                type: "cross_join",
                condition: "qqq",
            },
            {
                type: "inner_join",
                condition: "fefefe",
            },
        ],
        severityConfigurations: [{
            severity: 6,
            evalCondition: {
                condition: "__count__ > 1",
                countCondition: "cnt > 0",
            },
        }],
        labels: [{
            key: "a",
            value: "b",
        }],
        annotations: [{
            key: "x",
            value: "y",
        }],
        autoAnnotation: true,
        sendResolved: false,
        threshold: 1,
        noDataFire: false,
        sinkEventStore: {
            enabled: true,
            endpoint: "cn-shanghai-intranet.log.aliyuncs.com",
            project: "wkb-wangren",
            eventStore: "alert",
            roleArn: "acs:ram::1654218965343050:role/aliyunlogetlrole",
        },
        sinkCms: {
            enabled: false,
        },
        sinkAlerthub: {
            enabled: false,
        },
        templateConfiguration: {
            templateId: "sls.app.ack.autoscaler.cluster_unhealthy",
            type: "sys",
            version: "1.0",
            lang: "cn",
        },
        conditionConfiguration: {
            condition: "cnt > 3",
            countCondition: "__count__ < 3",
        },
        policyConfiguration: {
            alertPolicyId: "sls.builtin.dynamic",
            actionPolicyId: "wkb-action",
            repeatInterval: "1m",
        },
        dashboard: "internal-alert",
        muteUntil: 0,
        noDataSeverity: 6,
        tags: [
            "wkb",
            "wangren",
            "sls",
        ],
    },
    alertName: alertName,
    projectName: defaultINsMgl.id,
    schedule: {
        type: "Cron",
        runImmdiately: true,
        timeZone: "+0800",
        delay: 10,
        cronExpression: "0/5 * * * *",
    },
    displayName: "openapi-terraform",
    description: "create alert",
});
const _default = alicloud.sls.getAlertsOutput({
    ids: [defaultAlert.id],
    nameRegex: defaultAlert.alertName,
    projectName: defaultINsMgl.id,
});
export const alicloudSlsAlertExampleId = _default.apply(_default => _default.alerts?.[0]?.id);

import pulumi
import pulumi_alicloud as alicloud

config = pulumi.Config()
name = config.get("name")
if name is None:
    name = "terraform-example"
alert_name = config.get("alertName")
if alert_name is None:
    alert_name = "openapi-terraform-alert"
project_name = config.get("projectName")
if project_name is None:
    project_name = "terraform-alert-example"
default_ins_mgl = alicloud.log.Project("defaultINsMgl",
    description="terraform-alert-example",
    name="terraform-alert-example")
default_alert = alicloud.sls.Alert("default",
    configuration={
        "type": "tpl",
        "version": "2",
        "query_lists": [
            {
                "query": "* | select *",
                "time_span_type": "Relative",
                "start": "-15m",
                "end": "now",
                "store_type": "log",
                "project": default_ins_mgl.id,
                "store": "alert",
                "region": "cn-beijing",
                "power_sql_mode": "disable",
                "chart_title": "wkb-chart",
                "dashboard_id": "wkb-dashboard",
                "ui": "{}",
                "role_arn": "acs:ram::1654218965343050:role/aliyunslsalertmonitorrole",
            },
            {
                "store_type": "meta",
                "store": "user.rds_ip_whitelist",
            },
            {
                "store_type": "meta",
                "store": "myexample1",
            },
        ],
        "group_configuration": {
            "type": "no_group",
            "fields": [
                "a",
                "b",
            ],
        },
        "join_configurations": [
            {
                "type": "no_join",
                "condition": "aa",
            },
            {
                "type": "cross_join",
                "condition": "qqq",
            },
            {
                "type": "inner_join",
                "condition": "fefefe",
            },
        ],
        "severity_configurations": [{
            "severity": 6,
            "eval_condition": {
                "condition": "__count__ > 1",
                "count_condition": "cnt > 0",
            },
        }],
        "labels": [{
            "key": "a",
            "value": "b",
        }],
        "annotations": [{
            "key": "x",
            "value": "y",
        }],
        "auto_annotation": True,
        "send_resolved": False,
        "threshold": 1,
        "no_data_fire": False,
        "sink_event_store": {
            "enabled": True,
            "endpoint": "cn-shanghai-intranet.log.aliyuncs.com",
            "project": "wkb-wangren",
            "event_store": "alert",
            "role_arn": "acs:ram::1654218965343050:role/aliyunlogetlrole",
        },
        "sink_cms": {
            "enabled": False,
        },
        "sink_alerthub": {
            "enabled": False,
        },
        "template_configuration": {
            "template_id": "sls.app.ack.autoscaler.cluster_unhealthy",
            "type": "sys",
            "version": "1.0",
            "lang": "cn",
        },
        "condition_configuration": {
            "condition": "cnt > 3",
            "count_condition": "__count__ < 3",
        },
        "policy_configuration": {
            "alert_policy_id": "sls.builtin.dynamic",
            "action_policy_id": "wkb-action",
            "repeat_interval": "1m",
        },
        "dashboard": "internal-alert",
        "mute_until": 0,
        "no_data_severity": 6,
        "tags": [
            "wkb",
            "wangren",
            "sls",
        ],
    },
    alert_name=alert_name,
    project_name=default_ins_mgl.id,
    schedule={
        "type": "Cron",
        "run_immdiately": True,
        "time_zone": "+0800",
        "delay": 10,
        "cron_expression": "0/5 * * * *",
    },
    display_name="openapi-terraform",
    description="create alert")
default = alicloud.sls.get_alerts_output(ids=[default_alert.id],
    name_regex=default_alert.alert_name,
    project_name=default_ins_mgl.id)
pulumi.export("alicloudSlsAlertExampleId", default.alerts[0].id)

package main

import (
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/log"
	"github.com/pulumi/pulumi-alicloud/sdk/v3/go/alicloud/sls"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
cfg := config.New(ctx, "")
name := "terraform-example";
if param := cfg.Get("name"); param != ""{
name = param
}
alertName := "openapi-terraform-alert";
if param := cfg.Get("alertName"); param != ""{
alertName = param
}
projectName := "terraform-alert-example";
if param := cfg.Get("projectName"); param != ""{
projectName = param
}
defaultINsMgl, err := log.NewProject(ctx, "defaultINsMgl", &log.ProjectArgs{
Description: pulumi.String("terraform-alert-example"),
Name: pulumi.String("terraform-alert-example"),
})
if err != nil {
return err
}
defaultAlert, err := sls.NewAlert(ctx, "default", &sls.AlertArgs{
Configuration: &sls.AlertConfigurationArgs{
Type: pulumi.String("tpl"),
Version: pulumi.String("2"),
QueryLists: sls.AlertConfigurationQueryListArray{
&sls.AlertConfigurationQueryListArgs{
Query: pulumi.String("* | select *"),
TimeSpanType: pulumi.String("Relative"),
Start: pulumi.String("-15m"),
End: pulumi.String("now"),
StoreType: pulumi.String("log"),
Project: defaultINsMgl.ID(),
Store: pulumi.String("alert"),
Region: pulumi.String("cn-beijing"),
PowerSqlMode: pulumi.String("disable"),
ChartTitle: pulumi.String("wkb-chart"),
DashboardId: pulumi.String("wkb-dashboard"),
Ui: pulumi.String("{}"),
RoleArn: pulumi.String("acs:ram::1654218965343050:role/aliyunslsalertmonitorrole"),
},
&sls.AlertConfigurationQueryListArgs{
StoreType: pulumi.String("meta"),
Store: pulumi.String("user.rds_ip_whitelist"),
},
&sls.AlertConfigurationQueryListArgs{
StoreType: pulumi.String("meta"),
Store: pulumi.String("myexample1"),
},
},
GroupConfiguration: &sls.AlertConfigurationGroupConfigurationArgs{
Type: pulumi.String("no_group"),
Fields: pulumi.StringArray{
pulumi.String("a"),
pulumi.String("b"),
},
},
JoinConfigurations: sls.AlertConfigurationJoinConfigurationArray{
&sls.AlertConfigurationJoinConfigurationArgs{
Type: pulumi.String("no_join"),
Condition: pulumi.String("aa"),
},
&sls.AlertConfigurationJoinConfigurationArgs{
Type: pulumi.String("cross_join"),
Condition: pulumi.String("qqq"),
},
&sls.AlertConfigurationJoinConfigurationArgs{
Type: pulumi.String("inner_join"),
Condition: pulumi.String("fefefe"),
},
},
SeverityConfigurations: sls.AlertConfigurationSeverityConfigurationArray{
&sls.AlertConfigurationSeverityConfigurationArgs{
Severity: pulumi.Int(6),
EvalCondition: &sls.AlertConfigurationSeverityConfigurationEvalConditionArgs{
Condition: pulumi.String("__count__ > 1"),
CountCondition: pulumi.String("cnt > 0"),
},
},
},
Labels: sls.AlertConfigurationLabelArray{
&sls.AlertConfigurationLabelArgs{
Key: pulumi.String("a"),
Value: pulumi.String("b"),
},
},
Annotations: sls.AlertConfigurationAnnotationArray{
&sls.AlertConfigurationAnnotationArgs{
Key: pulumi.String("x"),
Value: pulumi.String("y"),
},
},
AutoAnnotation: pulumi.Bool(true),
SendResolved: pulumi.Bool(false),
Threshold: pulumi.Int(1),
NoDataFire: pulumi.Bool(false),
SinkEventStore: &sls.AlertConfigurationSinkEventStoreArgs{
Enabled: pulumi.Bool(true),
Endpoint: pulumi.String("cn-shanghai-intranet.log.aliyuncs.com"),
Project: pulumi.String("wkb-wangren"),
EventStore: pulumi.String("alert"),
RoleArn: pulumi.String("acs:ram::1654218965343050:role/aliyunlogetlrole"),
},
SinkCms: &sls.AlertConfigurationSinkCmsArgs{
Enabled: pulumi.Bool(false),
},
SinkAlerthub: &sls.AlertConfigurationSinkAlerthubArgs{
Enabled: pulumi.Bool(false),
},
TemplateConfiguration: &sls.AlertConfigurationTemplateConfigurationArgs{
TemplateId: pulumi.String("sls.app.ack.autoscaler.cluster_unhealthy"),
Type: pulumi.String("sys"),
Version: pulumi.String("1.0"),
Lang: pulumi.String("cn"),
},
ConditionConfiguration: &sls.AlertConfigurationConditionConfigurationArgs{
Condition: pulumi.String("cnt > 3"),
CountCondition: pulumi.String("__count__ < 3"),
},
PolicyConfiguration: &sls.AlertConfigurationPolicyConfigurationArgs{
AlertPolicyId: pulumi.String("sls.builtin.dynamic"),
ActionPolicyId: pulumi.String("wkb-action"),
RepeatInterval: pulumi.String("1m"),
},
Dashboard: pulumi.String("internal-alert"),
MuteUntil: pulumi.Int(0),
NoDataSeverity: pulumi.Int(6),
Tags: pulumi.StringArray{
pulumi.String("wkb"),
pulumi.String("wangren"),
pulumi.String("sls"),
},
},
AlertName: pulumi.String(alertName),
ProjectName: defaultINsMgl.ID(),
Schedule: &sls.AlertScheduleArgs{
Type: pulumi.String("Cron"),
RunImmdiately: pulumi.Bool(true),
TimeZone: pulumi.String("+0800"),
Delay: pulumi.Int(10),
CronExpression: pulumi.String("0/5 * * * *"),
},
DisplayName: pulumi.String("openapi-terraform"),
Description: pulumi.String("create alert"),
})
if err != nil {
return err
}
_default := sls.GetAlertsOutput(ctx, sls.GetAlertsOutputArgs{
Ids: pulumi.StringArray{
defaultAlert.ID(),
},
NameRegex: defaultAlert.AlertName,
ProjectName: defaultINsMgl.ID(),
}, nil);
ctx.Export("alicloudSlsAlertExampleId", _default.ApplyT(func(_default sls.GetAlertsResult) (*string, error) {
return &default.Alerts[0].Id, nil
}).(pulumi.StringPtrOutput))
return nil
})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var name = config.Get("name") ?? "terraform-example";
    var alertName = config.Get("alertName") ?? "openapi-terraform-alert";
    var projectName = config.Get("projectName") ?? "terraform-alert-example";
    var defaultINsMgl = new AliCloud.Log.Project("defaultINsMgl", new()
    {
        Description = "terraform-alert-example",
        Name = "terraform-alert-example",
    });

    var defaultAlert = new AliCloud.Sls.Alert("default", new()
    {
        Configuration = new AliCloud.Sls.Inputs.AlertConfigurationArgs
        {
            Type = "tpl",
            Version = "2",
            QueryLists = new[]
            {
                new AliCloud.Sls.Inputs.AlertConfigurationQueryListArgs
                {
                    Query = "* | select *",
                    TimeSpanType = "Relative",
                    Start = "-15m",
                    End = "now",
                    StoreType = "log",
                    Project = defaultINsMgl.Id,
                    Store = "alert",
                    Region = "cn-beijing",
                    PowerSqlMode = "disable",
                    ChartTitle = "wkb-chart",
                    DashboardId = "wkb-dashboard",
                    Ui = "{}",
                    RoleArn = "acs:ram::1654218965343050:role/aliyunslsalertmonitorrole",
                },
                new AliCloud.Sls.Inputs.AlertConfigurationQueryListArgs
                {
                    StoreType = "meta",
                    Store = "user.rds_ip_whitelist",
                },
                new AliCloud.Sls.Inputs.AlertConfigurationQueryListArgs
                {
                    StoreType = "meta",
                    Store = "myexample1",
                },
            },
            GroupConfiguration = new AliCloud.Sls.Inputs.AlertConfigurationGroupConfigurationArgs
            {
                Type = "no_group",
                Fields = new[]
                {
                    "a",
                    "b",
                },
            },
            JoinConfigurations = new[]
            {
                new AliCloud.Sls.Inputs.AlertConfigurationJoinConfigurationArgs
                {
                    Type = "no_join",
                    Condition = "aa",
                },
                new AliCloud.Sls.Inputs.AlertConfigurationJoinConfigurationArgs
                {
                    Type = "cross_join",
                    Condition = "qqq",
                },
                new AliCloud.Sls.Inputs.AlertConfigurationJoinConfigurationArgs
                {
                    Type = "inner_join",
                    Condition = "fefefe",
                },
            },
            SeverityConfigurations = new[]
            {
                new AliCloud.Sls.Inputs.AlertConfigurationSeverityConfigurationArgs
                {
                    Severity = 6,
                    EvalCondition = new AliCloud.Sls.Inputs.AlertConfigurationSeverityConfigurationEvalConditionArgs
                    {
                        Condition = "__count__ > 1",
                        CountCondition = "cnt > 0",
                    },
                },
            },
            Labels = new[]
            {
                new AliCloud.Sls.Inputs.AlertConfigurationLabelArgs
                {
                    Key = "a",
                    Value = "b",
                },
            },
            Annotations = new[]
            {
                new AliCloud.Sls.Inputs.AlertConfigurationAnnotationArgs
                {
                    Key = "x",
                    Value = "y",
                },
            },
            AutoAnnotation = true,
            SendResolved = false,
            Threshold = 1,
            NoDataFire = false,
            SinkEventStore = new AliCloud.Sls.Inputs.AlertConfigurationSinkEventStoreArgs
            {
                Enabled = true,
                Endpoint = "cn-shanghai-intranet.log.aliyuncs.com",
                Project = "wkb-wangren",
                EventStore = "alert",
                RoleArn = "acs:ram::1654218965343050:role/aliyunlogetlrole",
            },
            SinkCms = new AliCloud.Sls.Inputs.AlertConfigurationSinkCmsArgs
            {
                Enabled = false,
            },
            SinkAlerthub = new AliCloud.Sls.Inputs.AlertConfigurationSinkAlerthubArgs
            {
                Enabled = false,
            },
            TemplateConfiguration = new AliCloud.Sls.Inputs.AlertConfigurationTemplateConfigurationArgs
            {
                TemplateId = "sls.app.ack.autoscaler.cluster_unhealthy",
                Type = "sys",
                Version = "1.0",
                Lang = "cn",
            },
            ConditionConfiguration = new AliCloud.Sls.Inputs.AlertConfigurationConditionConfigurationArgs
            {
                Condition = "cnt > 3",
                CountCondition = "__count__ < 3",
            },
            PolicyConfiguration = new AliCloud.Sls.Inputs.AlertConfigurationPolicyConfigurationArgs
            {
                AlertPolicyId = "sls.builtin.dynamic",
                ActionPolicyId = "wkb-action",
                RepeatInterval = "1m",
            },
            Dashboard = "internal-alert",
            MuteUntil = 0,
            NoDataSeverity = 6,
            Tags = new[]
            {
                "wkb",
                "wangren",
                "sls",
            },
        },
        AlertName = alertName,
        ProjectName = defaultINsMgl.Id,
        Schedule = new AliCloud.Sls.Inputs.AlertScheduleArgs
        {
            Type = "Cron",
            RunImmdiately = true,
            TimeZone = "+0800",
            Delay = 10,
            CronExpression = "0/5 * * * *",
        },
        DisplayName = "openapi-terraform",
        Description = "create alert",
    });

    var @default = AliCloud.Sls.GetAlerts.Invoke(new()
    {
        Ids = new[]
        {
            defaultAlert.Id,
        },
        NameRegex = defaultAlert.AlertName,
        ProjectName = defaultINsMgl.Id,
    });

    return new Dictionary<string, object?>
    {
        ["alicloudSlsAlertExampleId"] = @default.Apply(@default => @default.Apply(getAlertsResult => getAlertsResult.Alerts[0]?.Id)),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.alicloud.log.Project;
import com.pulumi.alicloud.log.ProjectArgs;
import com.pulumi.alicloud.sls.Alert;
import com.pulumi.alicloud.sls.AlertArgs;
import com.pulumi.alicloud.sls.inputs.AlertConfigurationArgs;
import com.pulumi.alicloud.sls.inputs.AlertConfigurationGroupConfigurationArgs;
import com.pulumi.alicloud.sls.inputs.AlertConfigurationSinkEventStoreArgs;
import com.pulumi.alicloud.sls.inputs.AlertConfigurationSinkCmsArgs;
import com.pulumi.alicloud.sls.inputs.AlertConfigurationSinkAlerthubArgs;
import com.pulumi.alicloud.sls.inputs.AlertConfigurationTemplateConfigurationArgs;
import com.pulumi.alicloud.sls.inputs.AlertConfigurationConditionConfigurationArgs;
import com.pulumi.alicloud.sls.inputs.AlertConfigurationPolicyConfigurationArgs;
import com.pulumi.alicloud.sls.inputs.AlertScheduleArgs;
import com.pulumi.alicloud.sls.SlsFunctions;
import com.pulumi.alicloud.sls.inputs.GetAlertsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        final var config = ctx.config();
        final var name = config.get("name").orElse("terraform-example");
        final var alertName = config.get("alertName").orElse("openapi-terraform-alert");
        final var projectName = config.get("projectName").orElse("terraform-alert-example");
        var defaultINsMgl = new Project("defaultINsMgl", ProjectArgs.builder()
            .description("terraform-alert-example")
            .name("terraform-alert-example")
            .build());

        var defaultAlert = new Alert("defaultAlert", AlertArgs.builder()
            .configuration(AlertConfigurationArgs.builder()
                .type("tpl")
                .version("2")
                .queryLists(                
                    AlertConfigurationQueryListArgs.builder()
                        .query("* | select *")
                        .timeSpanType("Relative")
                        .start("-15m")
                        .end("now")
                        .storeType("log")
                        .project(defaultINsMgl.id())
                        .store("alert")
                        .region("cn-beijing")
                        .powerSqlMode("disable")
                        .chartTitle("wkb-chart")
                        .dashboardId("wkb-dashboard")
                        .ui("{}")
                        .roleArn("acs:ram::1654218965343050:role/aliyunslsalertmonitorrole")
                        .build(),
                    AlertConfigurationQueryListArgs.builder()
                        .storeType("meta")
                        .store("user.rds_ip_whitelist")
                        .build(),
                    AlertConfigurationQueryListArgs.builder()
                        .storeType("meta")
                        .store("myexample1")
                        .build())
                .groupConfiguration(AlertConfigurationGroupConfigurationArgs.builder()
                    .type("no_group")
                    .fields(                    
                        "a",
                        "b")
                    .build())
                .joinConfigurations(                
                    AlertConfigurationJoinConfigurationArgs.builder()
                        .type("no_join")
                        .condition("aa")
                        .build(),
                    AlertConfigurationJoinConfigurationArgs.builder()
                        .type("cross_join")
                        .condition("qqq")
                        .build(),
                    AlertConfigurationJoinConfigurationArgs.builder()
                        .type("inner_join")
                        .condition("fefefe")
                        .build())
                .severityConfigurations(AlertConfigurationSeverityConfigurationArgs.builder()
                    .severity(6)
                    .evalCondition(AlertConfigurationSeverityConfigurationEvalConditionArgs.builder()
                        .condition("__count__ > 1")
                        .countCondition("cnt > 0")
                        .build())
                    .build())
                .labels(AlertConfigurationLabelArgs.builder()
                    .key("a")
                    .value("b")
                    .build())
                .annotations(AlertConfigurationAnnotationArgs.builder()
                    .key("x")
                    .value("y")
                    .build())
                .autoAnnotation(true)
                .sendResolved(false)
                .threshold(1)
                .noDataFire(false)
                .sinkEventStore(AlertConfigurationSinkEventStoreArgs.builder()
                    .enabled(true)
                    .endpoint("cn-shanghai-intranet.log.aliyuncs.com")
                    .project("wkb-wangren")
                    .eventStore("alert")
                    .roleArn("acs:ram::1654218965343050:role/aliyunlogetlrole")
                    .build())
                .sinkCms(AlertConfigurationSinkCmsArgs.builder()
                    .enabled(false)
                    .build())
                .sinkAlerthub(AlertConfigurationSinkAlerthubArgs.builder()
                    .enabled(false)
                    .build())
                .templateConfiguration(AlertConfigurationTemplateConfigurationArgs.builder()
                    .templateId("sls.app.ack.autoscaler.cluster_unhealthy")
                    .type("sys")
                    .version("1.0")
                    .lang("cn")
                    .build())
                .conditionConfiguration(AlertConfigurationConditionConfigurationArgs.builder()
                    .condition("cnt > 3")
                    .countCondition("__count__ < 3")
                    .build())
                .policyConfiguration(AlertConfigurationPolicyConfigurationArgs.builder()
                    .alertPolicyId("sls.builtin.dynamic")
                    .actionPolicyId("wkb-action")
                    .repeatInterval("1m")
                    .build())
                .dashboard("internal-alert")
                .muteUntil(0)
                .noDataSeverity(6)
                .tags(                
                    "wkb",
                    "wangren",
                    "sls")
                .build())
            .alertName(alertName)
            .projectName(defaultINsMgl.id())
            .schedule(AlertScheduleArgs.builder()
                .type("Cron")
                .runImmdiately(true)
                .timeZone("+0800")
                .delay(10)
                .cronExpression("0/5 * * * *")
                .build())
            .displayName("openapi-terraform")
            .description("create alert")
            .build());

        final var default = SlsFunctions.getAlerts(GetAlertsArgs.builder()
            .ids(defaultAlert.id())
            .nameRegex(defaultAlert.alertName())
            .projectName(defaultINsMgl.id())
            .build());

        ctx.export("alicloudSlsAlertExampleId", default_.applyValue(_default_ -> _default_.alerts()[0].id()));
    }
}

configuration:
  name:
    type: string
    default: terraform-example
  alertName:
    type: string
    default: openapi-terraform-alert
  projectName:
    type: string
    default: terraform-alert-example
resources:
  defaultINsMgl:
    type: alicloud:log:Project
    properties:
      description: terraform-alert-example
      name: terraform-alert-example
  defaultAlert:
    type: alicloud:sls:Alert
    name: default
    properties:
      configuration:
        type: tpl
        version: '2'
        queryLists:
          - query: '* | select *'
            timeSpanType: Relative
            start: -15m
            end: now
            storeType: log
            project: ${defaultINsMgl.id}
            store: alert
            region: cn-beijing
            powerSqlMode: disable
            chartTitle: wkb-chart
            dashboardId: wkb-dashboard
            ui: '{}'
            roleArn: acs:ram::1654218965343050:role/aliyunslsalertmonitorrole
          - storeType: meta
            store: user.rds_ip_whitelist
          - storeType: meta
            store: myexample1
        groupConfiguration:
          type: no_group
          fields:
            - a
            - b
        joinConfigurations:
          - type: no_join
            condition: aa
          - type: cross_join
            condition: qqq
          - type: inner_join
            condition: fefefe
        severityConfigurations:
          - severity: '6'
            evalCondition:
              condition: __count__ > 1
              countCondition: cnt > 0
        labels:
          - key: a
            value: b
        annotations:
          - key: x
            value: y
        autoAnnotation: true
        sendResolved: false
        threshold: '1'
        noDataFire: false
        sinkEventStore:
          enabled: true
          endpoint: cn-shanghai-intranet.log.aliyuncs.com
          project: wkb-wangren
          eventStore: alert
          roleArn: acs:ram::1654218965343050:role/aliyunlogetlrole
        sinkCms:
          enabled: false
        sinkAlerthub:
          enabled: false
        templateConfiguration:
          templateId: sls.app.ack.autoscaler.cluster_unhealthy
          type: sys
          version: '1.0'
          lang: cn
        conditionConfiguration:
          condition: cnt > 3
          countCondition: __count__ < 3
        policyConfiguration:
          alertPolicyId: sls.builtin.dynamic
          actionPolicyId: wkb-action
          repeatInterval: 1m
        dashboard: internal-alert
        muteUntil: '0'
        noDataSeverity: '6'
        tags:
          - wkb
          - wangren
          - sls
      alertName: ${alertName}
      projectName: ${defaultINsMgl.id}
      schedule:
        type: Cron
        runImmdiately: true
        timeZone: '+0800'
        delay: '10'
        cronExpression: 0/5 * * * *
      displayName: openapi-terraform
      description: create alert
variables:
  default:
    fn::invoke:
      function: alicloud:sls:getAlerts
      arguments:
        ids:
          - ${defaultAlert.id}
        nameRegex: ${defaultAlert.alertName}
        projectName: ${defaultINsMgl.id}
outputs:
  alicloudSlsAlertExampleId: ${default.alerts[0].id}

function getAlerts(args: GetAlertsArgs, opts?: InvokeOptions): Promise<GetAlertsResult>
function getAlertsOutput(args: GetAlertsOutputArgs, opts?: InvokeOptions): Output<GetAlertsResult>

def get_alerts(ids: Optional[Sequence[str]] = None,
               name_regex: Optional[str] = None,
               output_file: Optional[str] = None,
               project_name: Optional[str] = None,
               opts: Optional[InvokeOptions] = None) -> GetAlertsResult
def get_alerts_output(ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
               name_regex: Optional[pulumi.Input[str]] = None,
               output_file: Optional[pulumi.Input[str]] = None,
               project_name: Optional[pulumi.Input[str]] = None,
               opts: Optional[InvokeOptions] = None) -> Output[GetAlertsResult]

func GetAlerts(ctx *Context, args *GetAlertsArgs, opts ...InvokeOption) (*GetAlertsResult, error)
func GetAlertsOutput(ctx *Context, args *GetAlertsOutputArgs, opts ...InvokeOption) GetAlertsResultOutput

public static class GetAlerts 
{
    public static Task<GetAlertsResult> InvokeAsync(GetAlertsArgs args, InvokeOptions? opts = null)
    public static Output<GetAlertsResult> Invoke(GetAlertsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAlertsResult> getAlerts(GetAlertsArgs args, InvokeOptions options)
public static Output<GetAlertsResult> getAlerts(GetAlertsArgs args, InvokeOptions options)

fn::invoke:
  function: alicloud:sls/getAlerts:getAlerts
  arguments:
    # arguments dictionary