Docs Home Pulumi IaC Pulumi ESC Pulumi Insights Pulumi Cloud Packages Tutorials
  1. Packages
  2. Checkly
  3. API Docs
  4. TcpCheck
Checkly v2.1.1 published on Tuesday, Mar 11, 2025 by Checkly
checkly/pulumi-checkly

checkly.TcpCheck

Explore with Pulumi AI

checkly logo
Checkly v2.1.1 published on Tuesday, Mar 11, 2025 by Checkly
checkly/pulumi-checkly

    TCP checks allow you to monitor remote endpoints at a lower level.

    Example Usage

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

// Basic TCP Check
const example_tcp_check = new checkly.TcpCheck("example-tcp-check", {
    name: "Example TCP check",
    activated: true,
    shouldFail: false,
    frequency: 1,
    useGlobalAlertSettings: true,
    locations: ["us-west-1"],
    request: {
        hostname: "api.checklyhq.com",
        port: 80,
    },
});
// A more complex example using assertions and setting alerts
const example_tcp_check_2 = new checkly.TcpCheck("example-tcp-check-2", {
    name: "Example TCP check 2",
    activated: true,
    shouldFail: true,
    frequency: 1,
    degradedResponseTime: 5000,
    maxResponseTime: 10000,
    locations: [
        "us-west-1",
        "ap-northeast-1",
        "ap-south-1",
    ],
    alertSettings: {
        escalationType: "RUN_BASED",
        runBasedEscalations: [{
            failedRunThreshold: 1,
        }],
        reminders: [{
            amount: 1,
        }],
    },
    retryStrategy: {
        type: "FIXED",
        baseBackoffSeconds: 60,
        maxDurationSeconds: 600,
        maxRetries: 3,
        sameRegion: false,
    },
    request: {
        hostname: "api.checklyhq.com",
        port: 80,
        data: "hello",
        assertions: [
            {
                source: "RESPONSE_DATA",
                property: "",
                comparison: "CONTAINS",
                target: "welcome",
            },
            {
                source: "RESPONSE_TIME",
                property: "",
                comparison: "LESS_THAN",
                target: "2000",
            },
        ],
    },
});

    import pulumi
import pulumi_checkly as checkly

# Basic TCP Check
example_tcp_check = checkly.TcpCheck("example-tcp-check",
    name="Example TCP check",
    activated=True,
    should_fail=False,
    frequency=1,
    use_global_alert_settings=True,
    locations=["us-west-1"],
    request={
        "hostname": "api.checklyhq.com",
        "port": 80,
    })
# A more complex example using assertions and setting alerts
example_tcp_check_2 = checkly.TcpCheck("example-tcp-check-2",
    name="Example TCP check 2",
    activated=True,
    should_fail=True,
    frequency=1,
    degraded_response_time=5000,
    max_response_time=10000,
    locations=[
        "us-west-1",
        "ap-northeast-1",
        "ap-south-1",
    ],
    alert_settings={
        "escalation_type": "RUN_BASED",
        "run_based_escalations": [{
            "failed_run_threshold": 1,
        }],
        "reminders": [{
            "amount": 1,
        }],
    },
    retry_strategy={
        "type": "FIXED",
        "base_backoff_seconds": 60,
        "max_duration_seconds": 600,
        "max_retries": 3,
        "same_region": False,
    },
    request={
        "hostname": "api.checklyhq.com",
        "port": 80,
        "data": "hello",
        "assertions": [
            {
                "source": "RESPONSE_DATA",
                "property": "",
                "comparison": "CONTAINS",
                "target": "welcome",
            },
            {
                "source": "RESPONSE_TIME",
                "property": "",
                "comparison": "LESS_THAN",
                "target": "2000",
            },
        ],
    })

    package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Basic TCP Check
		_, err := checkly.NewTcpCheck(ctx, "example-tcp-check", &checkly.TcpCheckArgs{
			Name:                   pulumi.String("Example TCP check"),
			Activated:              pulumi.Bool(true),
			ShouldFail:             pulumi.Bool(false),
			Frequency:              pulumi.Int(1),
			UseGlobalAlertSettings: pulumi.Bool(true),
			Locations: pulumi.StringArray{
				pulumi.String("us-west-1"),
			},
			Request: &checkly.TcpCheckRequestArgs{
				Hostname: pulumi.String("api.checklyhq.com"),
				Port:     pulumi.Int(80),
			},
		})
		if err != nil {
			return err
		}
		// A more complex example using assertions and setting alerts
		_, err = checkly.NewTcpCheck(ctx, "example-tcp-check-2", &checkly.TcpCheckArgs{
			Name:                 pulumi.String("Example TCP check 2"),
			Activated:            pulumi.Bool(true),
			ShouldFail:           pulumi.Bool(true),
			Frequency:            pulumi.Int(1),
			DegradedResponseTime: pulumi.Int(5000),
			MaxResponseTime:      pulumi.Int(10000),
			Locations: pulumi.StringArray{
				pulumi.String("us-west-1"),
				pulumi.String("ap-northeast-1"),
				pulumi.String("ap-south-1"),
			},
			AlertSettings: &checkly.TcpCheckAlertSettingsArgs{
				EscalationType: pulumi.String("RUN_BASED"),
				RunBasedEscalations: checkly.TcpCheckAlertSettingsRunBasedEscalationArray{
					&checkly.TcpCheckAlertSettingsRunBasedEscalationArgs{
						FailedRunThreshold: pulumi.Int(1),
					},
				},
				Reminders: checkly.TcpCheckAlertSettingsReminderArray{
					&checkly.TcpCheckAlertSettingsReminderArgs{
						Amount: pulumi.Int(1),
					},
				},
			},
			RetryStrategy: &checkly.TcpCheckRetryStrategyArgs{
				Type:               pulumi.String("FIXED"),
				BaseBackoffSeconds: pulumi.Int(60),
				MaxDurationSeconds: pulumi.Int(600),
				MaxRetries:         pulumi.Int(3),
				SameRegion:         pulumi.Bool(false),
			},
			Request: &checkly.TcpCheckRequestArgs{
				Hostname: pulumi.String("api.checklyhq.com"),
				Port:     pulumi.Int(80),
				Data:     pulumi.String("hello"),
				Assertions: checkly.TcpCheckRequestAssertionArray{
					&checkly.TcpCheckRequestAssertionArgs{
						Source:     pulumi.String("RESPONSE_DATA"),
						Property:   pulumi.String(""),
						Comparison: pulumi.String("CONTAINS"),
						Target:     pulumi.String("welcome"),
					},
					&checkly.TcpCheckRequestAssertionArgs{
						Source:     pulumi.String("RESPONSE_TIME"),
						Property:   pulumi.String(""),
						Comparison: pulumi.String("LESS_THAN"),
						Target:     pulumi.String("2000"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Basic TCP Check
    var example_tcp_check = new Checkly.TcpCheck("example-tcp-check", new()
    {
        Name = "Example TCP check",
        Activated = true,
        ShouldFail = false,
        Frequency = 1,
        UseGlobalAlertSettings = true,
        Locations = new[]
        {
            "us-west-1",
        },
        Request = new Checkly.Inputs.TcpCheckRequestArgs
        {
            Hostname = "api.checklyhq.com",
            Port = 80,
        },
    });

    // A more complex example using assertions and setting alerts
    var example_tcp_check_2 = new Checkly.TcpCheck("example-tcp-check-2", new()
    {
        Name = "Example TCP check 2",
        Activated = true,
        ShouldFail = true,
        Frequency = 1,
        DegradedResponseTime = 5000,
        MaxResponseTime = 10000,
        Locations = new[]
        {
            "us-west-1",
            "ap-northeast-1",
            "ap-south-1",
        },
        AlertSettings = new Checkly.Inputs.TcpCheckAlertSettingsArgs
        {
            EscalationType = "RUN_BASED",
            RunBasedEscalations = new[]
            {
                new Checkly.Inputs.TcpCheckAlertSettingsRunBasedEscalationArgs
                {
                    FailedRunThreshold = 1,
                },
            },
            Reminders = new[]
            {
                new Checkly.Inputs.TcpCheckAlertSettingsReminderArgs
                {
                    Amount = 1,
                },
            },
        },
        RetryStrategy = new Checkly.Inputs.TcpCheckRetryStrategyArgs
        {
            Type = "FIXED",
            BaseBackoffSeconds = 60,
            MaxDurationSeconds = 600,
            MaxRetries = 3,
            SameRegion = false,
        },
        Request = new Checkly.Inputs.TcpCheckRequestArgs
        {
            Hostname = "api.checklyhq.com",
            Port = 80,
            Data = "hello",
            Assertions = new[]
            {
                new Checkly.Inputs.TcpCheckRequestAssertionArgs
                {
                    Source = "RESPONSE_DATA",
                    Property = "",
                    Comparison = "CONTAINS",
                    Target = "welcome",
                },
                new Checkly.Inputs.TcpCheckRequestAssertionArgs
                {
                    Source = "RESPONSE_TIME",
                    Property = "",
                    Comparison = "LESS_THAN",
                    Target = "2000",
                },
            },
        },
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkly.TcpCheck;
import com.pulumi.checkly.TcpCheckArgs;
import com.pulumi.checkly.inputs.TcpCheckRequestArgs;
import com.pulumi.checkly.inputs.TcpCheckAlertSettingsArgs;
import com.pulumi.checkly.inputs.TcpCheckRetryStrategyArgs;
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) {
        // Basic TCP Check
        var example_tcp_check = new TcpCheck("example-tcp-check", TcpCheckArgs.builder()
            .name("Example TCP check")
            .activated(true)
            .shouldFail(false)
            .frequency(1)
            .useGlobalAlertSettings(true)
            .locations("us-west-1")
            .request(TcpCheckRequestArgs.builder()
                .hostname("api.checklyhq.com")
                .port(80)
                .build())
            .build());

        // A more complex example using assertions and setting alerts
        var example_tcp_check_2 = new TcpCheck("example-tcp-check-2", TcpCheckArgs.builder()
            .name("Example TCP check 2")
            .activated(true)
            .shouldFail(true)
            .frequency(1)
            .degradedResponseTime(5000)
            .maxResponseTime(10000)
            .locations(            
                "us-west-1",
                "ap-northeast-1",
                "ap-south-1")
            .alertSettings(TcpCheckAlertSettingsArgs.builder()
                .escalationType("RUN_BASED")
                .runBasedEscalations(TcpCheckAlertSettingsRunBasedEscalationArgs.builder()
                    .failedRunThreshold(1)
                    .build())
                .reminders(TcpCheckAlertSettingsReminderArgs.builder()
                    .amount(1)
                    .build())
                .build())
            .retryStrategy(TcpCheckRetryStrategyArgs.builder()
                .type("FIXED")
                .baseBackoffSeconds(60)
                .maxDurationSeconds(600)
                .maxRetries(3)
                .sameRegion(false)
                .build())
            .request(TcpCheckRequestArgs.builder()
                .hostname("api.checklyhq.com")
                .port(80)
                .data("hello")
                .assertions(                
                    TcpCheckRequestAssertionArgs.builder()
                        .source("RESPONSE_DATA")
                        .property("")
                        .comparison("CONTAINS")
                        .target("welcome")
                        .build(),
                    TcpCheckRequestAssertionArgs.builder()
                        .source("RESPONSE_TIME")
                        .property("")
                        .comparison("LESS_THAN")
                        .target("2000")
                        .build())
                .build())
            .build());

    }
}

    resources:
  # Basic TCP Check
  example-tcp-check:
    type: checkly:TcpCheck
    properties:
      name: Example TCP check
      activated: true
      shouldFail: false
      frequency: 1
      useGlobalAlertSettings: true
      locations:
        - us-west-1
      request:
        hostname: api.checklyhq.com
        port: 80
  # A more complex example using assertions and setting alerts
  example-tcp-check-2:
    type: checkly:TcpCheck
    properties:
      name: Example TCP check 2
      activated: true
      shouldFail: true
      frequency: 1
      degradedResponseTime: 5000
      maxResponseTime: 10000
      locations:
        - us-west-1
        - ap-northeast-1
        - ap-south-1
      alertSettings:
        escalationType: RUN_BASED
        runBasedEscalations:
          - failedRunThreshold: 1
        reminders:
          - amount: 1
      retryStrategy:
        type: FIXED
        baseBackoffSeconds: 60
        maxDurationSeconds: 600
        maxRetries: 3
        sameRegion: false
      request:
        hostname: api.checklyhq.com
        port: 80
        data: hello
        assertions:
          - source: RESPONSE_DATA
            property: ""
            comparison: CONTAINS
            target: welcome
          - source: RESPONSE_TIME
            property: ""
            comparison: LESS_THAN
            target: '2000'

    Create TcpCheck Resource

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

    Constructor syntax

    new TcpCheck(name: string, args: TcpCheckArgs, opts?: CustomResourceOptions);
    @overload
def TcpCheck(resource_name: str,
             args: TcpCheckArgs,
             opts: Optional[ResourceOptions] = None)

@overload
def TcpCheck(resource_name: str,
             opts: Optional[ResourceOptions] = None,
             frequency: Optional[int] = None,
             request: Optional[TcpCheckRequestArgs] = None,
             activated: Optional[bool] = None,
             muted: Optional[bool] = None,
             private_locations: Optional[Sequence[str]] = None,
             frequency_offset: Optional[int] = None,
             group_id: Optional[int] = None,
             group_order: Optional[int] = None,
             locations: Optional[Sequence[str]] = None,
             max_response_time: Optional[int] = None,
             alert_settings: Optional[TcpCheckAlertSettingsArgs] = None,
             name: Optional[str] = None,
             degraded_response_time: Optional[int] = None,
             alert_channel_subscriptions: Optional[Sequence[TcpCheckAlertChannelSubscriptionArgs]] = None,
             retry_strategy: Optional[TcpCheckRetryStrategyArgs] = None,
             run_parallel: Optional[bool] = None,
             runtime_id: Optional[str] = None,
             should_fail: Optional[bool] = None,
             tags: Optional[Sequence[str]] = None,
             use_global_alert_settings: Optional[bool] = None)
    func NewTcpCheck(ctx *Context, name string, args TcpCheckArgs, opts ...ResourceOption) (*TcpCheck, error)
    public TcpCheck(string name, TcpCheckArgs args, CustomResourceOptions? opts = null)
    public TcpCheck(String name, TcpCheckArgs args)
public TcpCheck(String name, TcpCheckArgs args, CustomResourceOptions options)

    type: checkly:TcpCheck
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

    Parameters

    name string
    The unique name of the resource.
    args TcpCheckArgs
    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 TcpCheckArgs
    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 TcpCheckArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args TcpCheckArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args TcpCheckArgs
    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 tcpCheckResource = new Checkly.TcpCheck("tcpCheckResource", new()
{
    Frequency = 0,
    Request = new Checkly.Inputs.TcpCheckRequestArgs
    {
        Hostname = "string",
        Port = 0,
        Assertions = new[]
        {
            new Checkly.Inputs.TcpCheckRequestAssertionArgs
            {
                Comparison = "string",
                Source = "string",
                Property = "string",
                Target = "string",
            },
        },
        Data = "string",
        IpFamily = "string",
    },
    Activated = false,
    Muted = false,
    PrivateLocations = new[]
    {
        "string",
    },
    FrequencyOffset = 0,
    GroupId = 0,
    GroupOrder = 0,
    Locations = new[]
    {
        "string",
    },
    MaxResponseTime = 0,
    AlertSettings = new Checkly.Inputs.TcpCheckAlertSettingsArgs
    {
        EscalationType = "string",
        ParallelRunFailureThresholds = new[]
        {
            new Checkly.Inputs.TcpCheckAlertSettingsParallelRunFailureThresholdArgs
            {
                Enabled = false,
                Percentage = 0,
            },
        },
        Reminders = new[]
        {
            new Checkly.Inputs.TcpCheckAlertSettingsReminderArgs
            {
                Amount = 0,
                Interval = 0,
            },
        },
        RunBasedEscalations = new[]
        {
            new Checkly.Inputs.TcpCheckAlertSettingsRunBasedEscalationArgs
            {
                FailedRunThreshold = 0,
            },
        },
        TimeBasedEscalations = new[]
        {
            new Checkly.Inputs.TcpCheckAlertSettingsTimeBasedEscalationArgs
            {
                MinutesFailingThreshold = 0,
            },
        },
    },
    Name = "string",
    DegradedResponseTime = 0,
    AlertChannelSubscriptions = new[]
    {
        new Checkly.Inputs.TcpCheckAlertChannelSubscriptionArgs
        {
            Activated = false,
            ChannelId = 0,
        },
    },
    RetryStrategy = new Checkly.Inputs.TcpCheckRetryStrategyArgs
    {
        Type = "string",
        BaseBackoffSeconds = 0,
        MaxDurationSeconds = 0,
        MaxRetries = 0,
        SameRegion = false,
    },
    RunParallel = false,
    RuntimeId = "string",
    ShouldFail = false,
    Tags = new[]
    {
        "string",
    },
    UseGlobalAlertSettings = false,
});

    example, err := checkly.NewTcpCheck(ctx, "tcpCheckResource", &checkly.TcpCheckArgs{
	Frequency: pulumi.Int(0),
	Request: &checkly.TcpCheckRequestArgs{
		Hostname: pulumi.String("string"),
		Port:     pulumi.Int(0),
		Assertions: checkly.TcpCheckRequestAssertionArray{
			&checkly.TcpCheckRequestAssertionArgs{
				Comparison: pulumi.String("string"),
				Source:     pulumi.String("string"),
				Property:   pulumi.String("string"),
				Target:     pulumi.String("string"),
			},
		},
		Data:     pulumi.String("string"),
		IpFamily: pulumi.String("string"),
	},
	Activated: pulumi.Bool(false),
	Muted:     pulumi.Bool(false),
	PrivateLocations: pulumi.StringArray{
		pulumi.String("string"),
	},
	FrequencyOffset: pulumi.Int(0),
	GroupId:         pulumi.Int(0),
	GroupOrder:      pulumi.Int(0),
	Locations: pulumi.StringArray{
		pulumi.String("string"),
	},
	MaxResponseTime: pulumi.Int(0),
	AlertSettings: &checkly.TcpCheckAlertSettingsArgs{
		EscalationType: pulumi.String("string"),
		ParallelRunFailureThresholds: checkly.TcpCheckAlertSettingsParallelRunFailureThresholdArray{
			&checkly.TcpCheckAlertSettingsParallelRunFailureThresholdArgs{
				Enabled:    pulumi.Bool(false),
				Percentage: pulumi.Int(0),
			},
		},
		Reminders: checkly.TcpCheckAlertSettingsReminderArray{
			&checkly.TcpCheckAlertSettingsReminderArgs{
				Amount:   pulumi.Int(0),
				Interval: pulumi.Int(0),
			},
		},
		RunBasedEscalations: checkly.TcpCheckAlertSettingsRunBasedEscalationArray{
			&checkly.TcpCheckAlertSettingsRunBasedEscalationArgs{
				FailedRunThreshold: pulumi.Int(0),
			},
		},
		TimeBasedEscalations: checkly.TcpCheckAlertSettingsTimeBasedEscalationArray{
			&checkly.TcpCheckAlertSettingsTimeBasedEscalationArgs{
				MinutesFailingThreshold: pulumi.Int(0),
			},
		},
	},
	Name:                 pulumi.String("string"),
	DegradedResponseTime: pulumi.Int(0),
	AlertChannelSubscriptions: checkly.TcpCheckAlertChannelSubscriptionArray{
		&checkly.TcpCheckAlertChannelSubscriptionArgs{
			Activated: pulumi.Bool(false),
			ChannelId: pulumi.Int(0),
		},
	},
	RetryStrategy: &checkly.TcpCheckRetryStrategyArgs{
		Type:               pulumi.String("string"),
		BaseBackoffSeconds: pulumi.Int(0),
		MaxDurationSeconds: pulumi.Int(0),
		MaxRetries:         pulumi.Int(0),
		SameRegion:         pulumi.Bool(false),
	},
	RunParallel: pulumi.Bool(false),
	RuntimeId:   pulumi.String("string"),
	ShouldFail:  pulumi.Bool(false),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
	UseGlobalAlertSettings: pulumi.Bool(false),
})

    var tcpCheckResource = new TcpCheck("tcpCheckResource", TcpCheckArgs.builder()
    .frequency(0)
    .request(TcpCheckRequestArgs.builder()
        .hostname("string")
        .port(0)
        .assertions(TcpCheckRequestAssertionArgs.builder()
            .comparison("string")
            .source("string")
            .property("string")
            .target("string")
            .build())
        .data("string")
        .ipFamily("string")
        .build())
    .activated(false)
    .muted(false)
    .privateLocations("string")
    .frequencyOffset(0)
    .groupId(0)
    .groupOrder(0)
    .locations("string")
    .maxResponseTime(0)
    .alertSettings(TcpCheckAlertSettingsArgs.builder()
        .escalationType("string")
        .parallelRunFailureThresholds(TcpCheckAlertSettingsParallelRunFailureThresholdArgs.builder()
            .enabled(false)
            .percentage(0)
            .build())
        .reminders(TcpCheckAlertSettingsReminderArgs.builder()
            .amount(0)
            .interval(0)
            .build())
        .runBasedEscalations(TcpCheckAlertSettingsRunBasedEscalationArgs.builder()
            .failedRunThreshold(0)
            .build())
        .timeBasedEscalations(TcpCheckAlertSettingsTimeBasedEscalationArgs.builder()
            .minutesFailingThreshold(0)
            .build())
        .build())
    .name("string")
    .degradedResponseTime(0)
    .alertChannelSubscriptions(TcpCheckAlertChannelSubscriptionArgs.builder()
        .activated(false)
        .channelId(0)
        .build())
    .retryStrategy(TcpCheckRetryStrategyArgs.builder()
        .type("string")
        .baseBackoffSeconds(0)
        .maxDurationSeconds(0)
        .maxRetries(0)
        .sameRegion(false)
        .build())
    .runParallel(false)
    .runtimeId("string")
    .shouldFail(false)
    .tags("string")
    .useGlobalAlertSettings(false)
    .build());

    tcp_check_resource = checkly.TcpCheck("tcpCheckResource",
    frequency=0,
    request={
        "hostname": "string",
        "port": 0,
        "assertions": [{
            "comparison": "string",
            "source": "string",
            "property": "string",
            "target": "string",
        }],
        "data": "string",
        "ip_family": "string",
    },
    activated=False,
    muted=False,
    private_locations=["string"],
    frequency_offset=0,
    group_id=0,
    group_order=0,
    locations=["string"],
    max_response_time=0,
    alert_settings={
        "escalation_type": "string",
        "parallel_run_failure_thresholds": [{
            "enabled": False,
            "percentage": 0,
        }],
        "reminders": [{
            "amount": 0,
            "interval": 0,
        }],
        "run_based_escalations": [{
            "failed_run_threshold": 0,
        }],
        "time_based_escalations": [{
            "minutes_failing_threshold": 0,
        }],
    },
    name="string",
    degraded_response_time=0,
    alert_channel_subscriptions=[{
        "activated": False,
        "channel_id": 0,
    }],
    retry_strategy={
        "type": "string",
        "base_backoff_seconds": 0,
        "max_duration_seconds": 0,
        "max_retries": 0,
        "same_region": False,
    },
    run_parallel=False,
    runtime_id="string",
    should_fail=False,
    tags=["string"],
    use_global_alert_settings=False)

    const tcpCheckResource = new checkly.TcpCheck("tcpCheckResource", {
    frequency: 0,
    request: {
        hostname: "string",
        port: 0,
        assertions: [{
            comparison: "string",
            source: "string",
            property: "string",
            target: "string",
        }],
        data: "string",
        ipFamily: "string",
    },
    activated: false,
    muted: false,
    privateLocations: ["string"],
    frequencyOffset: 0,
    groupId: 0,
    groupOrder: 0,
    locations: ["string"],
    maxResponseTime: 0,
    alertSettings: {
        escalationType: "string",
        parallelRunFailureThresholds: [{
            enabled: false,
            percentage: 0,
        }],
        reminders: [{
            amount: 0,
            interval: 0,
        }],
        runBasedEscalations: [{
            failedRunThreshold: 0,
        }],
        timeBasedEscalations: [{
            minutesFailingThreshold: 0,
        }],
    },
    name: "string",
    degradedResponseTime: 0,
    alertChannelSubscriptions: [{
        activated: false,
        channelId: 0,
    }],
    retryStrategy: {
        type: "string",
        baseBackoffSeconds: 0,
        maxDurationSeconds: 0,
        maxRetries: 0,
        sameRegion: false,
    },
    runParallel: false,
    runtimeId: "string",
    shouldFail: false,
    tags: ["string"],
    useGlobalAlertSettings: false,
});

    type: checkly:TcpCheck
properties:
    activated: false
    alertChannelSubscriptions:
        - activated: false
          channelId: 0
    alertSettings:
        escalationType: string
        parallelRunFailureThresholds:
            - enabled: false
              percentage: 0
        reminders:
            - amount: 0
              interval: 0
        runBasedEscalations:
            - failedRunThreshold: 0
        timeBasedEscalations:
            - minutesFailingThreshold: 0
    degradedResponseTime: 0
    frequency: 0
    frequencyOffset: 0
    groupId: 0
    groupOrder: 0
    locations:
        - string
    maxResponseTime: 0
    muted: false
    name: string
    privateLocations:
        - string
    request:
        assertions:
            - comparison: string
              property: string
              source: string
              target: string
        data: string
        hostname: string
        ipFamily: string
        port: 0
    retryStrategy:
        baseBackoffSeconds: 0
        maxDurationSeconds: 0
        maxRetries: 0
        sameRegion: false
        type: string
    runParallel: false
    runtimeId: string
    shouldFail: false
    tags:
        - string
    useGlobalAlertSettings: false

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

    Activated bool
    Determines if the check is running or not. Possible values true, and false.
    Frequency int
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    Request TcpCheckRequest
    The parameters for the TCP connection.
    AlertChannelSubscriptions List<TcpCheckAlertChannelSubscription>
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    AlertSettings TcpCheckAlertSettings
    DegradedResponseTime int
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    FrequencyOffset int
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    GroupId int
    The id of the check group this check is part of.
    GroupOrder int
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    Locations List<string>
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    MaxResponseTime int
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    Muted bool
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    Name string
    The name of the check.
    PrivateLocations List<string>
    An array of one or more private locations slugs.
    RetryStrategy TcpCheckRetryStrategy
    A strategy for retrying failed check runs.
    RunParallel bool
    Determines if the check should run in all selected locations in parallel or round-robin.
    RuntimeId string
    The ID of the runtime to use for this check.
    ShouldFail bool
    Allows to invert the behaviour of when a check is considered to fail.
    Tags List<string>
    A list of tags for organizing and filtering checks.
    UseGlobalAlertSettings bool
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    Activated bool
    Determines if the check is running or not. Possible values true, and false.
    Frequency int
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    Request TcpCheckRequestArgs
    The parameters for the TCP connection.
    AlertChannelSubscriptions []TcpCheckAlertChannelSubscriptionArgs
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    AlertSettings TcpCheckAlertSettingsArgs
    DegradedResponseTime int
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    FrequencyOffset int
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    GroupId int
    The id of the check group this check is part of.
    GroupOrder int
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    Locations []string
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    MaxResponseTime int
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    Muted bool
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    Name string
    The name of the check.
    PrivateLocations []string
    An array of one or more private locations slugs.
    RetryStrategy TcpCheckRetryStrategyArgs
    A strategy for retrying failed check runs.
    RunParallel bool
    Determines if the check should run in all selected locations in parallel or round-robin.
    RuntimeId string
    The ID of the runtime to use for this check.
    ShouldFail bool
    Allows to invert the behaviour of when a check is considered to fail.
    Tags []string
    A list of tags for organizing and filtering checks.
    UseGlobalAlertSettings bool
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    activated Boolean
    Determines if the check is running or not. Possible values true, and false.
    frequency Integer
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    request TcpCheckRequest
    The parameters for the TCP connection.
    alertChannelSubscriptions List<TcpCheckAlertChannelSubscription>
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    alertSettings TcpCheckAlertSettings
    degradedResponseTime Integer
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    frequencyOffset Integer
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    groupId Integer
    The id of the check group this check is part of.
    groupOrder Integer
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    locations List<String>
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    maxResponseTime Integer
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    muted Boolean
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    name String
    The name of the check.
    privateLocations List<String>
    An array of one or more private locations slugs.
    retryStrategy TcpCheckRetryStrategy
    A strategy for retrying failed check runs.
    runParallel Boolean
    Determines if the check should run in all selected locations in parallel or round-robin.
    runtimeId String
    The ID of the runtime to use for this check.
    shouldFail Boolean
    Allows to invert the behaviour of when a check is considered to fail.
    tags List<String>
    A list of tags for organizing and filtering checks.
    useGlobalAlertSettings Boolean
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    activated boolean
    Determines if the check is running or not. Possible values true, and false.
    frequency number
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    request TcpCheckRequest
    The parameters for the TCP connection.
    alertChannelSubscriptions TcpCheckAlertChannelSubscription[]
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    alertSettings TcpCheckAlertSettings
    degradedResponseTime number
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    frequencyOffset number
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    groupId number
    The id of the check group this check is part of.
    groupOrder number
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    locations string[]
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    maxResponseTime number
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    muted boolean
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    name string
    The name of the check.
    privateLocations string[]
    An array of one or more private locations slugs.
    retryStrategy TcpCheckRetryStrategy
    A strategy for retrying failed check runs.
    runParallel boolean
    Determines if the check should run in all selected locations in parallel or round-robin.
    runtimeId string
    The ID of the runtime to use for this check.
    shouldFail boolean
    Allows to invert the behaviour of when a check is considered to fail.
    tags string[]
    A list of tags for organizing and filtering checks.
    useGlobalAlertSettings boolean
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    activated bool
    Determines if the check is running or not. Possible values true, and false.
    frequency int
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    request TcpCheckRequestArgs
    The parameters for the TCP connection.
    alert_channel_subscriptions Sequence[TcpCheckAlertChannelSubscriptionArgs]
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    alert_settings TcpCheckAlertSettingsArgs
    degraded_response_time int
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    frequency_offset int
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    group_id int
    The id of the check group this check is part of.
    group_order int
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    locations Sequence[str]
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    max_response_time int
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    muted bool
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    name str
    The name of the check.
    private_locations Sequence[str]
    An array of one or more private locations slugs.
    retry_strategy TcpCheckRetryStrategyArgs
    A strategy for retrying failed check runs.
    run_parallel bool
    Determines if the check should run in all selected locations in parallel or round-robin.
    runtime_id str
    The ID of the runtime to use for this check.
    should_fail bool
    Allows to invert the behaviour of when a check is considered to fail.
    tags Sequence[str]
    A list of tags for organizing and filtering checks.
    use_global_alert_settings bool
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    activated Boolean
    Determines if the check is running or not. Possible values true, and false.
    frequency Number
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    request Property Map
    The parameters for the TCP connection.
    alertChannelSubscriptions List<Property Map>
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    alertSettings Property Map
    degradedResponseTime Number
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    frequencyOffset Number
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    groupId Number
    The id of the check group this check is part of.
    groupOrder Number
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    locations List<String>
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    maxResponseTime Number
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    muted Boolean
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    name String
    The name of the check.
    privateLocations List<String>
    An array of one or more private locations slugs.
    retryStrategy Property Map
    A strategy for retrying failed check runs.
    runParallel Boolean
    Determines if the check should run in all selected locations in parallel or round-robin.
    runtimeId String
    The ID of the runtime to use for this check.
    shouldFail Boolean
    Allows to invert the behaviour of when a check is considered to fail.
    tags List<String>
    A list of tags for organizing and filtering checks.
    useGlobalAlertSettings Boolean
    When true, the account level alert settings will be used, not the alert setting defined on this check.

    Outputs

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

    Id string
    The provider-assigned unique ID for this managed resource.
    Id string
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.
    id string
    The provider-assigned unique ID for this managed resource.
    id str
    The provider-assigned unique ID for this managed resource.
    id String
    The provider-assigned unique ID for this managed resource.

    Look up Existing TcpCheck Resource

    Get an existing TcpCheck 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?: TcpCheckState, opts?: CustomResourceOptions): TcpCheck
    @staticmethod
def get(resource_name: str,
        id: str,
        opts: Optional[ResourceOptions] = None,
        activated: Optional[bool] = None,
        alert_channel_subscriptions: Optional[Sequence[TcpCheckAlertChannelSubscriptionArgs]] = None,
        alert_settings: Optional[TcpCheckAlertSettingsArgs] = None,
        degraded_response_time: Optional[int] = None,
        frequency: Optional[int] = None,
        frequency_offset: Optional[int] = None,
        group_id: Optional[int] = None,
        group_order: Optional[int] = None,
        locations: Optional[Sequence[str]] = None,
        max_response_time: Optional[int] = None,
        muted: Optional[bool] = None,
        name: Optional[str] = None,
        private_locations: Optional[Sequence[str]] = None,
        request: Optional[TcpCheckRequestArgs] = None,
        retry_strategy: Optional[TcpCheckRetryStrategyArgs] = None,
        run_parallel: Optional[bool] = None,
        runtime_id: Optional[str] = None,
        should_fail: Optional[bool] = None,
        tags: Optional[Sequence[str]] = None,
        use_global_alert_settings: Optional[bool] = None) -> TcpCheck
    func GetTcpCheck(ctx *Context, name string, id IDInput, state *TcpCheckState, opts ...ResourceOption) (*TcpCheck, error)
    public static TcpCheck Get(string name, Input<string> id, TcpCheckState? state, CustomResourceOptions? opts = null)
    public static TcpCheck get(String name, Output<String> id, TcpCheckState state, CustomResourceOptions options)
    resources:  _:    type: checkly:TcpCheck    get:      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:
    Activated bool
    Determines if the check is running or not. Possible values true, and false.
    AlertChannelSubscriptions List<TcpCheckAlertChannelSubscription>
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    AlertSettings TcpCheckAlertSettings
    DegradedResponseTime int
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    Frequency int
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    FrequencyOffset int
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    GroupId int
    The id of the check group this check is part of.
    GroupOrder int
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    Locations List<string>
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    MaxResponseTime int
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    Muted bool
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    Name string
    The name of the check.
    PrivateLocations List<string>
    An array of one or more private locations slugs.
    Request TcpCheckRequest
    The parameters for the TCP connection.
    RetryStrategy TcpCheckRetryStrategy
    A strategy for retrying failed check runs.
    RunParallel bool
    Determines if the check should run in all selected locations in parallel or round-robin.
    RuntimeId string
    The ID of the runtime to use for this check.
    ShouldFail bool
    Allows to invert the behaviour of when a check is considered to fail.
    Tags List<string>
    A list of tags for organizing and filtering checks.
    UseGlobalAlertSettings bool
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    Activated bool
    Determines if the check is running or not. Possible values true, and false.
    AlertChannelSubscriptions []TcpCheckAlertChannelSubscriptionArgs
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    AlertSettings TcpCheckAlertSettingsArgs
    DegradedResponseTime int
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    Frequency int
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    FrequencyOffset int
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    GroupId int
    The id of the check group this check is part of.
    GroupOrder int
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    Locations []string
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    MaxResponseTime int
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    Muted bool
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    Name string
    The name of the check.
    PrivateLocations []string
    An array of one or more private locations slugs.
    Request TcpCheckRequestArgs
    The parameters for the TCP connection.
    RetryStrategy TcpCheckRetryStrategyArgs
    A strategy for retrying failed check runs.
    RunParallel bool
    Determines if the check should run in all selected locations in parallel or round-robin.
    RuntimeId string
    The ID of the runtime to use for this check.
    ShouldFail bool
    Allows to invert the behaviour of when a check is considered to fail.
    Tags []string
    A list of tags for organizing and filtering checks.
    UseGlobalAlertSettings bool
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    activated Boolean
    Determines if the check is running or not. Possible values true, and false.
    alertChannelSubscriptions List<TcpCheckAlertChannelSubscription>
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    alertSettings TcpCheckAlertSettings
    degradedResponseTime Integer
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    frequency Integer
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    frequencyOffset Integer
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    groupId Integer
    The id of the check group this check is part of.
    groupOrder Integer
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    locations List<String>
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    maxResponseTime Integer
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    muted Boolean
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    name String
    The name of the check.
    privateLocations List<String>
    An array of one or more private locations slugs.
    request TcpCheckRequest
    The parameters for the TCP connection.
    retryStrategy TcpCheckRetryStrategy
    A strategy for retrying failed check runs.
    runParallel Boolean
    Determines if the check should run in all selected locations in parallel or round-robin.
    runtimeId String
    The ID of the runtime to use for this check.
    shouldFail Boolean
    Allows to invert the behaviour of when a check is considered to fail.
    tags List<String>
    A list of tags for organizing and filtering checks.
    useGlobalAlertSettings Boolean
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    activated boolean
    Determines if the check is running or not. Possible values true, and false.
    alertChannelSubscriptions TcpCheckAlertChannelSubscription[]
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    alertSettings TcpCheckAlertSettings
    degradedResponseTime number
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    frequency number
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    frequencyOffset number
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    groupId number
    The id of the check group this check is part of.
    groupOrder number
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    locations string[]
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    maxResponseTime number
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    muted boolean
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    name string
    The name of the check.
    privateLocations string[]
    An array of one or more private locations slugs.
    request TcpCheckRequest
    The parameters for the TCP connection.
    retryStrategy TcpCheckRetryStrategy
    A strategy for retrying failed check runs.
    runParallel boolean
    Determines if the check should run in all selected locations in parallel or round-robin.
    runtimeId string
    The ID of the runtime to use for this check.
    shouldFail boolean
    Allows to invert the behaviour of when a check is considered to fail.
    tags string[]
    A list of tags for organizing and filtering checks.
    useGlobalAlertSettings boolean
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    activated bool
    Determines if the check is running or not. Possible values true, and false.
    alert_channel_subscriptions Sequence[TcpCheckAlertChannelSubscriptionArgs]
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    alert_settings TcpCheckAlertSettingsArgs
    degraded_response_time int
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    frequency int
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    frequency_offset int
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    group_id int
    The id of the check group this check is part of.
    group_order int
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    locations Sequence[str]
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    max_response_time int
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    muted bool
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    name str
    The name of the check.
    private_locations Sequence[str]
    An array of one or more private locations slugs.
    request TcpCheckRequestArgs
    The parameters for the TCP connection.
    retry_strategy TcpCheckRetryStrategyArgs
    A strategy for retrying failed check runs.
    run_parallel bool
    Determines if the check should run in all selected locations in parallel or round-robin.
    runtime_id str
    The ID of the runtime to use for this check.
    should_fail bool
    Allows to invert the behaviour of when a check is considered to fail.
    tags Sequence[str]
    A list of tags for organizing and filtering checks.
    use_global_alert_settings bool
    When true, the account level alert settings will be used, not the alert setting defined on this check.
    activated Boolean
    Determines if the check is running or not. Possible values true, and false.
    alertChannelSubscriptions List<Property Map>
    An array of channel IDs and whether they're activated or not. If you don't set at least one alert subscription for your check, we won't be able to alert you in case something goes wrong with it.
    alertSettings Property Map
    degradedResponseTime Number
    The response time in milliseconds starting from which a check should be considered degraded. Possible values are between 0 and 5000. (Default 4000).
    frequency Number
    The frequency in minutes to run the check. Possible values are 0, 1, 2, 5, 10, 15, 30, 60, 120, 180, 360, 720, and 1440.
    frequencyOffset Number
    To create a high frequency check, the property frequency must be 0 and frequency_offset can be 10, 20 or 30.
    groupId Number
    The id of the check group this check is part of.
    groupOrder Number
    The position of this check in a check group. It determines in what order checks are run when a group is triggered from the API or from CI/CD.
    locations List<String>
    An array of one or more data center locations where to run the this check. (Default ["us-east-1"])
    maxResponseTime Number
    The response time in milliseconds starting from which a check should be considered failing. Possible values are between 0 and 5000. (Default 5000).
    muted Boolean
    Determines if any notifications will be sent out when a check fails/degrades/recovers.
    name String
    The name of the check.
    privateLocations List<String>
    An array of one or more private locations slugs.
    request Property Map
    The parameters for the TCP connection.
    retryStrategy Property Map
    A strategy for retrying failed check runs.
    runParallel Boolean
    Determines if the check should run in all selected locations in parallel or round-robin.
    runtimeId String
    The ID of the runtime to use for this check.
    shouldFail Boolean
    Allows to invert the behaviour of when a check is considered to fail.
    tags List<String>
    A list of tags for organizing and filtering checks.
    useGlobalAlertSettings Boolean
    When true, the account level alert settings will be used, not the alert setting defined on this check.

    Supporting Types

    TcpCheckAlertChannelSubscription, TcpCheckAlertChannelSubscriptionArgs

    activated Boolean
    channelId Integer
    activated boolean
    channelId number
    activated Boolean
    channelId Number

    TcpCheckAlertSettings, TcpCheckAlertSettingsArgs

    TcpCheckAlertSettingsParallelRunFailureThreshold, TcpCheckAlertSettingsParallelRunFailureThresholdArgs

    Enabled bool
    Applicable only for checks scheduled in parallel in multiple locations.
    Percentage int
    Possible values are 10, 20, 30, 40, 50, 60, 70, 80, 100, and 100. (Default 10).
    Enabled bool
    Applicable only for checks scheduled in parallel in multiple locations.
    Percentage int
    Possible values are 10, 20, 30, 40, 50, 60, 70, 80, 100, and 100. (Default 10).
    enabled Boolean
    Applicable only for checks scheduled in parallel in multiple locations.
    percentage Integer
    Possible values are 10, 20, 30, 40, 50, 60, 70, 80, 100, and 100. (Default 10).
    enabled boolean
    Applicable only for checks scheduled in parallel in multiple locations.
    percentage number
    Possible values are 10, 20, 30, 40, 50, 60, 70, 80, 100, and 100. (Default 10).
    enabled bool
    Applicable only for checks scheduled in parallel in multiple locations.
    percentage int
    Possible values are 10, 20, 30, 40, 50, 60, 70, 80, 100, and 100. (Default 10).
    enabled Boolean
    Applicable only for checks scheduled in parallel in multiple locations.
    percentage Number
    Possible values are 10, 20, 30, 40, 50, 60, 70, 80, 100, and 100. (Default 10).

    TcpCheckAlertSettingsReminder, TcpCheckAlertSettingsReminderArgs

    Amount int
    How many reminders to send out after the initial alert notification. Possible values are 0, 1, 2, 3, 4, 5, and 100000
    Interval int
    Possible values are 5, 10, 15, and 30. (Default 5).
    Amount int
    How many reminders to send out after the initial alert notification. Possible values are 0, 1, 2, 3, 4, 5, and 100000
    Interval int
    Possible values are 5, 10, 15, and 30. (Default 5).
    amount Integer
    How many reminders to send out after the initial alert notification. Possible values are 0, 1, 2, 3, 4, 5, and 100000
    interval Integer
    Possible values are 5, 10, 15, and 30. (Default 5).
    amount number
    How many reminders to send out after the initial alert notification. Possible values are 0, 1, 2, 3, 4, 5, and 100000
    interval number
    Possible values are 5, 10, 15, and 30. (Default 5).
    amount int
    How many reminders to send out after the initial alert notification. Possible values are 0, 1, 2, 3, 4, 5, and 100000
    interval int
    Possible values are 5, 10, 15, and 30. (Default 5).
    amount Number
    How many reminders to send out after the initial alert notification. Possible values are 0, 1, 2, 3, 4, 5, and 100000
    interval Number
    Possible values are 5, 10, 15, and 30. (Default 5).

    TcpCheckAlertSettingsRunBasedEscalation, TcpCheckAlertSettingsRunBasedEscalationArgs

    FailedRunThreshold int
    After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default 1).
    FailedRunThreshold int
    After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default 1).
    failedRunThreshold Integer
    After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default 1).
    failedRunThreshold number
    After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default 1).
    failed_run_threshold int
    After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default 1).
    failedRunThreshold Number
    After how many failed consecutive check runs an alert notification should be sent. Possible values are between 1 and 5. (Default 1).

    TcpCheckAlertSettingsTimeBasedEscalation, TcpCheckAlertSettingsTimeBasedEscalationArgs

    MinutesFailingThreshold int
    After how many minutes after a check starts failing an alert should be sent. Possible values are 5, 10, 15, and 30. (Default 5).
    MinutesFailingThreshold int
    After how many minutes after a check starts failing an alert should be sent. Possible values are 5, 10, 15, and 30. (Default 5).
    minutesFailingThreshold Integer
    After how many minutes after a check starts failing an alert should be sent. Possible values are 5, 10, 15, and 30. (Default 5).
    minutesFailingThreshold number
    After how many minutes after a check starts failing an alert should be sent. Possible values are 5, 10, 15, and 30. (Default 5).
    minutes_failing_threshold int
    After how many minutes after a check starts failing an alert should be sent. Possible values are 5, 10, 15, and 30. (Default 5).
    minutesFailingThreshold Number
    After how many minutes after a check starts failing an alert should be sent. Possible values are 5, 10, 15, and 30. (Default 5).

    TcpCheckRequest, TcpCheckRequestArgs

    Hostname string
    The hostname or IP to connect to. Do not include a scheme or a port in this value.
    Port int
    The port number to connect to.
    Assertions List<TcpCheckRequestAssertion>
    A request can have multiple assertions.
    Data string
    The data to send to the target host.
    IpFamily string
    The IP family to use when executing the TCP check. The value can be either IPv4 or IPv6.
    Hostname string
    The hostname or IP to connect to. Do not include a scheme or a port in this value.
    Port int
    The port number to connect to.
    Assertions []TcpCheckRequestAssertion
    A request can have multiple assertions.
    Data string
    The data to send to the target host.
    IpFamily string
    The IP family to use when executing the TCP check. The value can be either IPv4 or IPv6.
    hostname String
    The hostname or IP to connect to. Do not include a scheme or a port in this value.
    port Integer
    The port number to connect to.
    assertions List<TcpCheckRequestAssertion>
    A request can have multiple assertions.
    data String
    The data to send to the target host.
    ipFamily String
    The IP family to use when executing the TCP check. The value can be either IPv4 or IPv6.
    hostname string
    The hostname or IP to connect to. Do not include a scheme or a port in this value.
    port number
    The port number to connect to.
    assertions TcpCheckRequestAssertion[]
    A request can have multiple assertions.
    data string
    The data to send to the target host.
    ipFamily string
    The IP family to use when executing the TCP check. The value can be either IPv4 or IPv6.
    hostname str
    The hostname or IP to connect to. Do not include a scheme or a port in this value.
    port int
    The port number to connect to.
    assertions Sequence[TcpCheckRequestAssertion]
    A request can have multiple assertions.
    data str
    The data to send to the target host.
    ip_family str
    The IP family to use when executing the TCP check. The value can be either IPv4 or IPv6.
    hostname String
    The hostname or IP to connect to. Do not include a scheme or a port in this value.
    port Number
    The port number to connect to.
    assertions List<Property Map>
    A request can have multiple assertions.
    data String
    The data to send to the target host.
    ipFamily String
    The IP family to use when executing the TCP check. The value can be either IPv4 or IPv6.

    TcpCheckRequestAssertion, TcpCheckRequestAssertionArgs

    Comparison string
    The type of comparison to be executed between expected and actual value of the assertion. Possible values are EQUALS, NOT_EQUALS, HAS_KEY, NOT_HAS_KEY, HAS_VALUE, NOT_HAS_VALUE, IS_EMPTY, NOT_EMPTY, GREATER_THAN, LESS_THAN, CONTAINS, NOT_CONTAINS, IS_NULL, and NOT_NULL.
    Source string
    The source of the asserted value. Possible values are RESPONSE_DATA and RESPONSE_TIME.
    Property string
    Target string
    Comparison string
    The type of comparison to be executed between expected and actual value of the assertion. Possible values are EQUALS, NOT_EQUALS, HAS_KEY, NOT_HAS_KEY, HAS_VALUE, NOT_HAS_VALUE, IS_EMPTY, NOT_EMPTY, GREATER_THAN, LESS_THAN, CONTAINS, NOT_CONTAINS, IS_NULL, and NOT_NULL.
    Source string
    The source of the asserted value. Possible values are RESPONSE_DATA and RESPONSE_TIME.
    Property string
    Target string
    comparison String
    The type of comparison to be executed between expected and actual value of the assertion. Possible values are EQUALS, NOT_EQUALS, HAS_KEY, NOT_HAS_KEY, HAS_VALUE, NOT_HAS_VALUE, IS_EMPTY, NOT_EMPTY, GREATER_THAN, LESS_THAN, CONTAINS, NOT_CONTAINS, IS_NULL, and NOT_NULL.
    source String
    The source of the asserted value. Possible values are RESPONSE_DATA and RESPONSE_TIME.
    property String
    target String
    comparison string
    The type of comparison to be executed between expected and actual value of the assertion. Possible values are EQUALS, NOT_EQUALS, HAS_KEY, NOT_HAS_KEY, HAS_VALUE, NOT_HAS_VALUE, IS_EMPTY, NOT_EMPTY, GREATER_THAN, LESS_THAN, CONTAINS, NOT_CONTAINS, IS_NULL, and NOT_NULL.
    source string
    The source of the asserted value. Possible values are RESPONSE_DATA and RESPONSE_TIME.
    property string
    target string
    comparison str
    The type of comparison to be executed between expected and actual value of the assertion. Possible values are EQUALS, NOT_EQUALS, HAS_KEY, NOT_HAS_KEY, HAS_VALUE, NOT_HAS_VALUE, IS_EMPTY, NOT_EMPTY, GREATER_THAN, LESS_THAN, CONTAINS, NOT_CONTAINS, IS_NULL, and NOT_NULL.
    source str
    The source of the asserted value. Possible values are RESPONSE_DATA and RESPONSE_TIME.
    property str
    target str
    comparison String
    The type of comparison to be executed between expected and actual value of the assertion. Possible values are EQUALS, NOT_EQUALS, HAS_KEY, NOT_HAS_KEY, HAS_VALUE, NOT_HAS_VALUE, IS_EMPTY, NOT_EMPTY, GREATER_THAN, LESS_THAN, CONTAINS, NOT_CONTAINS, IS_NULL, and NOT_NULL.
    source String
    The source of the asserted value. Possible values are RESPONSE_DATA and RESPONSE_TIME.
    property String
    target String

    TcpCheckRetryStrategy, TcpCheckRetryStrategyArgs

    Type string
    Determines which type of retry strategy to use. Possible values are FIXED, LINEAR, or EXPONENTIAL.
    BaseBackoffSeconds int
    The number of seconds to wait before the first retry attempt.
    MaxDurationSeconds int
    The total amount of time to continue retrying the check (maximum 600 seconds).
    MaxRetries int
    The maximum number of times to retry the check. Value must be between 1 and 10.
    SameRegion bool
    Whether retries should be run in the same region as the initial check run.
    Type string
    Determines which type of retry strategy to use. Possible values are FIXED, LINEAR, or EXPONENTIAL.
    BaseBackoffSeconds int
    The number of seconds to wait before the first retry attempt.
    MaxDurationSeconds int
    The total amount of time to continue retrying the check (maximum 600 seconds).
    MaxRetries int
    The maximum number of times to retry the check. Value must be between 1 and 10.
    SameRegion bool
    Whether retries should be run in the same region as the initial check run.
    type String
    Determines which type of retry strategy to use. Possible values are FIXED, LINEAR, or EXPONENTIAL.
    baseBackoffSeconds Integer
    The number of seconds to wait before the first retry attempt.
    maxDurationSeconds Integer
    The total amount of time to continue retrying the check (maximum 600 seconds).
    maxRetries Integer
    The maximum number of times to retry the check. Value must be between 1 and 10.
    sameRegion Boolean
    Whether retries should be run in the same region as the initial check run.
    type string
    Determines which type of retry strategy to use. Possible values are FIXED, LINEAR, or EXPONENTIAL.
    baseBackoffSeconds number
    The number of seconds to wait before the first retry attempt.
    maxDurationSeconds number
    The total amount of time to continue retrying the check (maximum 600 seconds).
    maxRetries number
    The maximum number of times to retry the check. Value must be between 1 and 10.
    sameRegion boolean
    Whether retries should be run in the same region as the initial check run.
    type str
    Determines which type of retry strategy to use. Possible values are FIXED, LINEAR, or EXPONENTIAL.
    base_backoff_seconds int
    The number of seconds to wait before the first retry attempt.
    max_duration_seconds int
    The total amount of time to continue retrying the check (maximum 600 seconds).
    max_retries int
    The maximum number of times to retry the check. Value must be between 1 and 10.
    same_region bool
    Whether retries should be run in the same region as the initial check run.
    type String
    Determines which type of retry strategy to use. Possible values are FIXED, LINEAR, or EXPONENTIAL.
    baseBackoffSeconds Number
    The number of seconds to wait before the first retry attempt.
    maxDurationSeconds Number
    The total amount of time to continue retrying the check (maximum 600 seconds).
    maxRetries Number
    The maximum number of times to retry the check. Value must be between 1 and 10.
    sameRegion Boolean
    Whether retries should be run in the same region as the initial check run.

    Package Details

    Repository
    checkly checkly/pulumi-checkly
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the checkly Terraform Provider.
    checkly logo
    Checkly v2.1.1 published on Tuesday, Mar 11, 2025 by Checkly
    checkly/pulumi-checkly