pulumi-gcp-kotlin/com.pulumi.gcp.monitoring.kotlin/UptimeCheckConfig

UptimeCheckConfig

class UptimeCheckConfig : KotlinCustomResource

This message configures which resources and services to monitor for availability. To get more information about UptimeCheckConfig, see:

API documentation
How-to Guides

Official Documentation

Example Usage

Uptime Check Config Http

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.monitoring.UptimeCheckConfig;
import com.pulumi.gcp.monitoring.UptimeCheckConfigArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigContentMatcherArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigContentMatcherJsonPathMatcherArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigHttpCheckArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigHttpCheckPingConfigArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigMonitoredResourceArgs;
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) {
        var http = new UptimeCheckConfig("http", UptimeCheckConfigArgs.builder()
            .checkerType("STATIC_IP_CHECKERS")
            .contentMatchers(UptimeCheckConfigContentMatcherArgs.builder()
                .content("\"example\"")
                .jsonPathMatcher(UptimeCheckConfigContentMatcherJsonPathMatcherArgs.builder()
                    .jsonMatcher("EXACT_MATCH")
                    .jsonPath("$.path")
                    .build())
                .matcher("MATCHES_JSON_PATH")
                .build())
            .displayName("http-uptime-check")
            .httpCheck(UptimeCheckConfigHttpCheckArgs.builder()
                .body("Zm9vJTI1M0RiYXI=")
                .contentType("USER_PROVIDED")
                .customContentType("application/json")
                .path("some-path")
                .pingConfig(UptimeCheckConfigHttpCheckPingConfigArgs.builder()
                    .pingsCount(1)
                    .build())
                .port("8010")
                .requestMethod("POST")
                .build())
            .monitoredResource(UptimeCheckConfigMonitoredResourceArgs.builder()
                .labels(Map.ofEntries(
                    Map.entry("host", "192.168.1.1"),
                    Map.entry("projectId", "my-project-name")
                ))
                .type("uptime_url")
                .build())
            .timeout("60s")
            .userLabels(Map.of("example-key", "example-value"))
            .build());
    }
}

Uptime Check Config Status Code

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.monitoring.UptimeCheckConfig;
import com.pulumi.gcp.monitoring.UptimeCheckConfigArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigContentMatcherArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigContentMatcherJsonPathMatcherArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigHttpCheckArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigMonitoredResourceArgs;
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) {
        var statusCode = new UptimeCheckConfig("statusCode", UptimeCheckConfigArgs.builder()
            .checkerType("STATIC_IP_CHECKERS")
            .contentMatchers(UptimeCheckConfigContentMatcherArgs.builder()
                .content("\"example\"")
                .jsonPathMatcher(UptimeCheckConfigContentMatcherJsonPathMatcherArgs.builder()
                    .jsonMatcher("EXACT_MATCH")
                    .jsonPath("$.path")
                    .build())
                .matcher("MATCHES_JSON_PATH")
                .build())
            .displayName("http-uptime-check")
            .httpCheck(UptimeCheckConfigHttpCheckArgs.builder()
                .acceptedResponseStatusCodes(
                    UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgs.builder()
                        .statusClass("STATUS_CLASS_2XX")
                        .build(),
                    UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgs.builder()
                        .statusValue(301)
                        .build(),
                    UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgs.builder()
                        .statusValue(302)
                        .build())
                .body("Zm9vJTI1M0RiYXI=")
                .contentType("URL_ENCODED")
                .path("some-path")
                .port("8010")
                .requestMethod("POST")
                .build())
            .monitoredResource(UptimeCheckConfigMonitoredResourceArgs.builder()
                .labels(Map.ofEntries(
                    Map.entry("host", "192.168.1.1"),
                    Map.entry("projectId", "my-project-name")
                ))
                .type("uptime_url")
                .build())
            .timeout("60s")
            .build());
    }
}

Uptime Check Config Https

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.monitoring.UptimeCheckConfig;
import com.pulumi.gcp.monitoring.UptimeCheckConfigArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigContentMatcherArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigContentMatcherJsonPathMatcherArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigHttpCheckArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigMonitoredResourceArgs;
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) {
        var https = new UptimeCheckConfig("https", UptimeCheckConfigArgs.builder()
            .contentMatchers(UptimeCheckConfigContentMatcherArgs.builder()
                .content("example")
                .jsonPathMatcher(UptimeCheckConfigContentMatcherJsonPathMatcherArgs.builder()
                    .jsonMatcher("REGEX_MATCH")
                    .jsonPath("$.path")
                    .build())
                .matcher("MATCHES_JSON_PATH")
                .build())
            .displayName("https-uptime-check")
            .httpCheck(UptimeCheckConfigHttpCheckArgs.builder()
                .path("/some-path")
                .port("443")
                .useSsl(true)
                .validateSsl(true)
                .build())
            .monitoredResource(UptimeCheckConfigMonitoredResourceArgs.builder()
                .labels(Map.ofEntries(
                    Map.entry("host", "192.168.1.1"),
                    Map.entry("projectId", "my-project-name")
                ))
                .type("uptime_url")
                .build())
            .timeout("60s")
            .build());
    }
}

Uptime Check Tcp

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.monitoring.Group;
import com.pulumi.gcp.monitoring.GroupArgs;
import com.pulumi.gcp.monitoring.UptimeCheckConfig;
import com.pulumi.gcp.monitoring.UptimeCheckConfigArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigTcpCheckArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigTcpCheckPingConfigArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigResourceGroupArgs;
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) {
        var check = new Group("check", GroupArgs.builder()
            .displayName("uptime-check-group")
            .filter("resource.metadata.name=has_substring(\"foo\")")
            .build());
        var tcpGroup = new UptimeCheckConfig("tcpGroup", UptimeCheckConfigArgs.builder()
            .displayName("tcp-uptime-check")
            .timeout("60s")
            .tcpCheck(UptimeCheckConfigTcpCheckArgs.builder()
                .port(888)
                .pingConfig(UptimeCheckConfigTcpCheckPingConfigArgs.builder()
                    .pingsCount(2)
                    .build())
                .build())
            .resourceGroup(UptimeCheckConfigResourceGroupArgs.builder()
                .resourceType("INSTANCE")
                .groupId(check.name())
                .build())
            .build());
    }
}

Uptime Check Config Synthetic Monitor

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.storage.BucketObject;
import com.pulumi.gcp.storage.BucketObjectArgs;
import com.pulumi.gcp.cloudfunctionsv2.Function;
import com.pulumi.gcp.cloudfunctionsv2.FunctionArgs;
import com.pulumi.gcp.cloudfunctionsv2.inputs.FunctionBuildConfigArgs;
import com.pulumi.gcp.cloudfunctionsv2.inputs.FunctionBuildConfigSourceArgs;
import com.pulumi.gcp.cloudfunctionsv2.inputs.FunctionBuildConfigSourceStorageSourceArgs;
import com.pulumi.gcp.cloudfunctionsv2.inputs.FunctionServiceConfigArgs;
import com.pulumi.gcp.monitoring.UptimeCheckConfig;
import com.pulumi.gcp.monitoring.UptimeCheckConfigArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigSyntheticMonitorArgs;
import com.pulumi.gcp.monitoring.inputs.UptimeCheckConfigSyntheticMonitorCloudFunctionV2Args;
import com.pulumi.asset.FileAsset;
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) {
        var bucket = new Bucket("bucket", BucketArgs.builder()
            .location("US")
            .uniformBucketLevelAccess(true)
            .build());
        var object = new BucketObject("object", BucketObjectArgs.builder()
            .bucket(bucket.name())
            .source(new FileAsset("synthetic-fn-source.zip"))
            .build());
        var function = new Function("function", FunctionArgs.builder()
            .location("us-central1")
            .buildConfig(FunctionBuildConfigArgs.builder()
                .runtime("nodejs16")
                .entryPoint("SyntheticFunction")
                .source(FunctionBuildConfigSourceArgs.builder()
                    .storageSource(FunctionBuildConfigSourceStorageSourceArgs.builder()
                        .bucket(bucket.name())
                        .object(object.name())
                        .build())
                    .build())
                .build())
            .serviceConfig(FunctionServiceConfigArgs.builder()
                .maxInstanceCount(1)
                .availableMemory("256M")
                .timeoutSeconds(60)
                .build())
            .build());
        var syntheticMonitor = new UptimeCheckConfig("syntheticMonitor", UptimeCheckConfigArgs.builder()
            .displayName("synthetic_monitor")
            .timeout("60s")
            .syntheticMonitor(UptimeCheckConfigSyntheticMonitorArgs.builder()
                .cloudFunctionV2(UptimeCheckConfigSyntheticMonitorCloudFunctionV2Args.builder()
                    .name(function.id())
                    .build())
                .build())
            .build());
    }
}

Import

UptimeCheckConfig can be imported using any of these accepted formats* {{name}} In Terraform v1.5.0 and later, use an import block to import UptimeCheckConfig using one of the formats above. For exampletf import { id = "{{name}}" to = google_monitoring_uptime_check_config.default }

$ pulumi import gcp:monitoring/uptimeCheckConfig:UptimeCheckConfig When using the [`terraform import` command](https://developer.hashicorp.com/terraform/cli/commands/import), UptimeCheckConfig can be imported using one of the formats above. For example

$ pulumi import gcp:monitoring/uptimeCheckConfig:UptimeCheckConfig default {{name}}

Properties

checkerType

val checkerType: Output<String>

The checker type to use for the check. If the monitored resource type is servicedirectory_service, checker_type must be set to VPC_CHECKERS. Possible values are: STATIC_IP_CHECKERS, VPC_CHECKERS.

contentMatchers

val contentMatchers: Output<List<UptimeCheckConfigContentMatcher>>?

The expected content on the page the check is run against. Currently, only the first entry in the list is supported, and other entries will be ignored. The server will look for an exact match of the string in the page response's content. This field is optional and should only be specified if a content match is required. Structure is documented below.

displayName

val displayName: Output<String>

A human-friendly name for the uptime check configuration. The display name should be unique within a Stackdriver Workspace in order to make it easier to identify; however, uniqueness is not enforced.

httpCheck

val httpCheck: Output<UptimeCheckConfigHttpCheck>?

Contains information needed to make an HTTP or HTTPS check. Structure is documented below.

val id: Output<String>

monitoredResource

val monitoredResource: Output<UptimeCheckConfigMonitoredResource>?

The monitored resource (https://cloud.google.com/monitoring/api/resources) associated with the configuration. The following monitored resource types are supported for uptime checks:

name

val name: Output<String>

The fully qualified name of the cloud function resource.

period

val period: Output<String>?

How often, in seconds, the uptime check is performed. Currently, the only supported values are 60s (1 minute), 300s (5 minutes), 600s (10 minutes), and 900s (15 minutes). Optional, defaults to 300s.

project

val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

resourceGroup

val resourceGroup: Output<UptimeCheckConfigResourceGroup>?

The group resource associated with the configuration. Structure is documented below.

selectedRegions

val selectedRegions: Output<List<String>>?

The list of regions from which the check will be run. Some regions contain one location, and others contain more than one. If this field is specified, enough regions to include a minimum of 3 locations must be provided, or an error message is returned. Not specifying this field will result in uptime checks running from all regions.

syntheticMonitor

val syntheticMonitor: Output<UptimeCheckConfigSyntheticMonitor>?

A Synthetic Monitor deployed to a Cloud Functions V2 instance. Structure is documented below.

tcpCheck

val tcpCheck: Output<UptimeCheckConfigTcpCheck>?

Contains information needed to make a TCP check. Structure is documented below.

timeout

val timeout: Output<String>

The maximum amount of time to wait for the request to complete (must be between 1 and 60 seconds). See the accepted formats

uptimeCheckId

val uptimeCheckId: Output<String>

The id of the uptime check

urn

val urn: Output<String>

userLabels

val userLabels: Output<Map<String, String>>?

User-supplied key/value data to be used for organizing and identifying the UptimeCheckConfig objects. The field can contain up to 64 entries. Each key and value is limited to 63 Unicode characters or 128 bytes, whichever is smaller. Labels and values can contain only lowercase letters, numerals, underscores, and dashes. Keys must begin with a letter.