checkly.CheckGroup

using Pulumi;
using Checkly = Pulumi.Checkly;

class MyStack : Stack
{
    public MyStack()
    {
        var testGroup1CheckGroup = new Checkly.CheckGroup("testGroup1CheckGroup", new Checkly.CheckGroupArgs
        {
            Activated = true,
            Muted = false,
            Tags = 
            {
                "auto",
            },
            Locations = 
            {
                "eu-west-1",
            },
            Concurrency = 3,
            ApiCheckDefaults = new Checkly.Inputs.CheckGroupApiCheckDefaultsArgs
            {
                Url = "http://example.com/",
                Headers = 
                {
                    { "X-Test", "foo" },
                },
                QueryParameters = 
                {
                    { "query", "foo" },
                },
                Assertions = 
                {
                    new Checkly.Inputs.CheckGroupApiCheckDefaultsAssertionArgs
                    {
                        Source = "STATUS_CODE",
                        Property = "",
                        Comparison = "EQUALS",
                        Target = "200",
                    },
                    new Checkly.Inputs.CheckGroupApiCheckDefaultsAssertionArgs
                    {
                        Source = "TEXT_BODY",
                        Property = "",
                        Comparison = "CONTAINS",
                        Target = "welcome",
                    },
                },
                BasicAuth = new Checkly.Inputs.CheckGroupApiCheckDefaultsBasicAuthArgs
                {
                    Username = "user",
                    Password = "pass",
                },
            },
            EnvironmentVariables = 
            {
                { "ENVTEST", "Hello world" },
            },
            DoubleCheck = true,
            UseGlobalAlertSettings = false,
            AlertSettings = new Checkly.Inputs.CheckGroupAlertSettingsArgs
            {
                EscalationType = "RUN_BASED",
                RunBasedEscalations = 
                {
                    new Checkly.Inputs.CheckGroupAlertSettingsRunBasedEscalationArgs
                    {
                        FailedRunThreshold = 1,
                    },
                },
                TimeBasedEscalations = 
                {
                    new Checkly.Inputs.CheckGroupAlertSettingsTimeBasedEscalationArgs
                    {
                        MinutesFailingThreshold = 5,
                    },
                },
                Reminders = 
                {
                    new Checkly.Inputs.CheckGroupAlertSettingsReminderArgs
                    {
                        Amount = 2,
                        Interval = 5,
                    },
                },
            },
            LocalSetupScript = "setup-test",
            LocalTeardownScript = "teardown-test",
        });
        // Add a check to a group
        var testCheck1 = new Checkly.Check("testCheck1", new Checkly.CheckArgs
        {
            GroupId = testGroup1CheckGroup.Id,
            GroupOrder = 1,
        });
        // Using with alert channels
        var emailAc1 = new Checkly.AlertChannel("emailAc1", new Checkly.AlertChannelArgs
        {
            Email = new Checkly.Inputs.AlertChannelEmailArgs
            {
                Address = "info@example.com",
            },
        });
        var emailAc2 = new Checkly.AlertChannel("emailAc2", new Checkly.AlertChannelArgs
        {
            Email = new Checkly.Inputs.AlertChannelEmailArgs
            {
                Address = "info2@example.com",
            },
        });
        // Connect the check group to the alert channels
        var testGroup1Index_checkGroupCheckGroup = new Checkly.CheckGroup("testGroup1Index/checkGroupCheckGroup", new Checkly.CheckGroupArgs
        {
            AlertChannelSubscriptions = 
            {
                new Checkly.Inputs.CheckGroupAlertChannelSubscriptionArgs
                {
                    ChannelId = emailAc1.Id,
                    Activated = true,
                },
                new Checkly.Inputs.CheckGroupAlertChannelSubscriptionArgs
                {
                    ChannelId = emailAc2.Id,
                    Activated = true,
                },
            },
        });
    }

}

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testGroup1CheckGroup, err := checkly.NewCheckGroup(ctx, "testGroup1CheckGroup", &checkly.CheckGroupArgs{
			Activated: pulumi.Bool(true),
			Muted:     pulumi.Bool(false),
			Tags: pulumi.StringArray{
				pulumi.String("auto"),
			},
			Locations: pulumi.StringArray{
				pulumi.String("eu-west-1"),
			},
			Concurrency: pulumi.Int(3),
			ApiCheckDefaults: &CheckGroupApiCheckDefaultsArgs{
				Url: pulumi.String("http://example.com/"),
				Headers: pulumi.AnyMap{
					"X-Test": pulumi.Any("foo"),
				},
				QueryParameters: pulumi.AnyMap{
					"query": pulumi.Any("foo"),
				},
				Assertions: CheckGroupApiCheckDefaultsAssertionArray{
					&CheckGroupApiCheckDefaultsAssertionArgs{
						Source:     pulumi.String("STATUS_CODE"),
						Property:   pulumi.String(""),
						Comparison: pulumi.String("EQUALS"),
						Target:     pulumi.String("200"),
					},
					&CheckGroupApiCheckDefaultsAssertionArgs{
						Source:     pulumi.String("TEXT_BODY"),
						Property:   pulumi.String(""),
						Comparison: pulumi.String("CONTAINS"),
						Target:     pulumi.String("welcome"),
					},
				},
				BasicAuth: &CheckGroupApiCheckDefaultsBasicAuthArgs{
					Username: pulumi.String("user"),
					Password: pulumi.String("pass"),
				},
			},
			EnvironmentVariables: pulumi.AnyMap{
				"ENVTEST": pulumi.Any("Hello world"),
			},
			DoubleCheck:            pulumi.Bool(true),
			UseGlobalAlertSettings: pulumi.Bool(false),
			AlertSettings: &CheckGroupAlertSettingsArgs{
				EscalationType: pulumi.String("RUN_BASED"),
				RunBasedEscalations: CheckGroupAlertSettingsRunBasedEscalationArray{
					&CheckGroupAlertSettingsRunBasedEscalationArgs{
						FailedRunThreshold: pulumi.Int(1),
					},
				},
				TimeBasedEscalations: CheckGroupAlertSettingsTimeBasedEscalationArray{
					&CheckGroupAlertSettingsTimeBasedEscalationArgs{
						MinutesFailingThreshold: pulumi.Int(5),
					},
				},
				Reminders: CheckGroupAlertSettingsReminderArray{
					&CheckGroupAlertSettingsReminderArgs{
						Amount:   pulumi.Int(2),
						Interval: pulumi.Int(5),
					},
				},
			},
			LocalSetupScript:    pulumi.String("setup-test"),
			LocalTeardownScript: pulumi.String("teardown-test"),
		})
		if err != nil {
			return err
		}
		_, err = checkly.NewCheck(ctx, "testCheck1", &checkly.CheckArgs{
			GroupId:    testGroup1CheckGroup.ID(),
			GroupOrder: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		emailAc1, err := checkly.NewAlertChannel(ctx, "emailAc1", &checkly.AlertChannelArgs{
			Email: &AlertChannelEmailArgs{
				Address: pulumi.String("info@example.com"),
			},
		})
		if err != nil {
			return err
		}
		emailAc2, err := checkly.NewAlertChannel(ctx, "emailAc2", &checkly.AlertChannelArgs{
			Email: &AlertChannelEmailArgs{
				Address: pulumi.String("info2@example.com"),
			},
		})
		if err != nil {
			return err
		}
		_, err = checkly.NewCheckGroup(ctx, "testGroup1Index/checkGroupCheckGroup", &checkly.CheckGroupArgs{
			AlertChannelSubscriptions: CheckGroupAlertChannelSubscriptionArray{
				&CheckGroupAlertChannelSubscriptionArgs{
					ChannelId: emailAc1.ID(),
					Activated: pulumi.Bool(true),
				},
				&CheckGroupAlertChannelSubscriptionArgs{
					ChannelId: emailAc2.ID(),
					Activated: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import pulumi
import pulumi_checkly as checkly

test_group1_check_group = checkly.CheckGroup("testGroup1CheckGroup",
    activated=True,
    muted=False,
    tags=["auto"],
    locations=["eu-west-1"],
    concurrency=3,
    api_check_defaults=checkly.CheckGroupApiCheckDefaultsArgs(
        url="http://example.com/",
        headers={
            "X-Test": "foo",
        },
        query_parameters={
            "query": "foo",
        },
        assertions=[
            checkly.CheckGroupApiCheckDefaultsAssertionArgs(
                source="STATUS_CODE",
                property="",
                comparison="EQUALS",
                target="200",
            ),
            checkly.CheckGroupApiCheckDefaultsAssertionArgs(
                source="TEXT_BODY",
                property="",
                comparison="CONTAINS",
                target="welcome",
            ),
        ],
        basic_auth=checkly.CheckGroupApiCheckDefaultsBasicAuthArgs(
            username="user",
            password="pass",
        ),
    ),
    environment_variables={
        "ENVTEST": "Hello world",
    },
    double_check=True,
    use_global_alert_settings=False,
    alert_settings=checkly.CheckGroupAlertSettingsArgs(
        escalation_type="RUN_BASED",
        run_based_escalations=[checkly.CheckGroupAlertSettingsRunBasedEscalationArgs(
            failed_run_threshold=1,
        )],
        time_based_escalations=[checkly.CheckGroupAlertSettingsTimeBasedEscalationArgs(
            minutes_failing_threshold=5,
        )],
        reminders=[checkly.CheckGroupAlertSettingsReminderArgs(
            amount=2,
            interval=5,
        )],
    ),
    local_setup_script="setup-test",
    local_teardown_script="teardown-test")
# Add a check to a group
test_check1 = checkly.Check("testCheck1",
    group_id=test_group1_check_group.id,
    group_order=1)
# Using with alert channels
email_ac1 = checkly.AlertChannel("emailAc1", email=checkly.AlertChannelEmailArgs(
    address="info@example.com",
))
email_ac2 = checkly.AlertChannel("emailAc2", email=checkly.AlertChannelEmailArgs(
    address="info2@example.com",
))
# Connect the check group to the alert channels
test_group1_index_check_group_check_group = checkly.CheckGroup("testGroup1Index/checkGroupCheckGroup", alert_channel_subscriptions=[
    checkly.CheckGroupAlertChannelSubscriptionArgs(
        channel_id=email_ac1.id,
        activated=True,
    ),
    checkly.CheckGroupAlertChannelSubscriptionArgs(
        channel_id=email_ac2.id,
        activated=True,
    ),
])

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

const testGroup1CheckGroup = new checkly.CheckGroup("testGroup1CheckGroup", {
    activated: true,
    muted: false,
    tags: ["auto"],
    locations: ["eu-west-1"],
    concurrency: 3,
    apiCheckDefaults: {
        url: "http://example.com/",
        headers: {
            "X-Test": "foo",
        },
        queryParameters: {
            query: "foo",
        },
        assertions: [
            {
                source: "STATUS_CODE",
                property: "",
                comparison: "EQUALS",
                target: "200",
            },
            {
                source: "TEXT_BODY",
                property: "",
                comparison: "CONTAINS",
                target: "welcome",
            },
        ],
        basicAuth: {
            username: "user",
            password: "pass",
        },
    },
    environmentVariables: {
        ENVTEST: "Hello world",
    },
    doubleCheck: true,
    useGlobalAlertSettings: false,
    alertSettings: {
        escalationType: "RUN_BASED",
        runBasedEscalations: [{
            failedRunThreshold: 1,
        }],
        timeBasedEscalations: [{
            minutesFailingThreshold: 5,
        }],
        reminders: [{
            amount: 2,
            interval: 5,
        }],
    },
    localSetupScript: "setup-test",
    localTeardownScript: "teardown-test",
});
// Add a check to a group
const testCheck1 = new checkly.Check("testCheck1", {
    groupId: testGroup1CheckGroup.id,
    groupOrder: 1,
});
// Using with alert channels
const emailAc1 = new checkly.AlertChannel("emailAc1", {email: {
    address: "info@example.com",
}});
const emailAc2 = new checkly.AlertChannel("emailAc2", {email: {
    address: "info2@example.com",
}});
// Connect the check group to the alert channels
const testGroup1Index_checkGroupCheckGroup = new checkly.CheckGroup("testGroup1Index/checkGroupCheckGroup", {alertChannelSubscriptions: [
    {
        channelId: emailAc1.id,
        activated: true,
    },
    {
        channelId: emailAc2.id,
        activated: true,
    },
]});