pulumi-gcp-kotlin/com.pulumi.gcp.compute.kotlin/RegionHealthCheckArgs

RegionHealthCheckArgs

data class RegionHealthCheckArgs(val checkIntervalSec: Output<Int>? = null, val description: Output<String>? = null, val grpcHealthCheck: Output<RegionHealthCheckGrpcHealthCheckArgs>? = null, val grpcTlsHealthCheck: Output<RegionHealthCheckGrpcTlsHealthCheckArgs>? = null, val healthyThreshold: Output<Int>? = null, val http2HealthCheck: Output<RegionHealthCheckHttp2HealthCheckArgs>? = null, val httpHealthCheck: Output<RegionHealthCheckHttpHealthCheckArgs>? = null, val httpsHealthCheck: Output<RegionHealthCheckHttpsHealthCheckArgs>? = null, val logConfig: Output<RegionHealthCheckLogConfigArgs>? = null, val name: Output<String>? = null, val project: Output<String>? = null, val region: Output<String>? = null, val sslHealthCheck: Output<RegionHealthCheckSslHealthCheckArgs>? = null, val tcpHealthCheck: Output<RegionHealthCheckTcpHealthCheckArgs>? = null, val timeoutSec: Output<Int>? = null, val unhealthyThreshold: Output<Int>? = null) : ConvertibleToJava<RegionHealthCheckArgs>

Health Checks determine whether instances are responsive and able to do work. They are an important part of a comprehensive load balancing configuration, as they enable monitoring instances behind load balancers. Health Checks poll instances at a specified interval. Instances that do not respond successfully to some number of probes in a row are marked as unhealthy. No new connections are sent to unhealthy instances, though existing connections will continue. The health check will continue to poll unhealthy instances. If an instance later responds successfully to some number of consecutive probes, it is marked healthy again and can receive new connections. To get more information about RegionHealthCheck, see:

Example Usage

Region Health Check Tcp

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const tcp_region_health_check = new gcp.compute.RegionHealthCheck("tcp-region-health-check", {
    name: "tcp-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    tcpHealthCheck: {
        port: 80,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
tcp_region_health_check = gcp.compute.RegionHealthCheck("tcp-region-health-check",
    name="tcp-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    tcp_health_check={
        "port": 80,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var tcp_region_health_check = new Gcp.Compute.RegionHealthCheck("tcp-region-health-check", new()
    {
        Name = "tcp-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        TcpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckTcpHealthCheckArgs
        {
            Port = 80,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "tcp-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("tcp-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			TcpHealthCheck: &compute.RegionHealthCheckTcpHealthCheckArgs{
				Port: pulumi.Int(80),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckTcpHealthCheckArgs;
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 tcp_region_health_check = new RegionHealthCheck("tcp-region-health-check", RegionHealthCheckArgs.builder()
            .name("tcp-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .tcpHealthCheck(RegionHealthCheckTcpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  tcp-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: tcp-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      tcpHealthCheck:
        port: '80'
Content copied to clipboard

Region Health Check Tcp Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const tcp_region_health_check = new gcp.compute.RegionHealthCheck("tcp-region-health-check", {
    name: "tcp-region-health-check",
    description: "Health check via tcp",
    timeoutSec: 1,
    checkIntervalSec: 1,
    healthyThreshold: 4,
    unhealthyThreshold: 5,
    tcpHealthCheck: {
        portName: "health-check-port",
        portSpecification: "USE_NAMED_PORT",
        request: "ARE YOU HEALTHY?",
        proxyHeader: "NONE",
        response: "I AM HEALTHY",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
tcp_region_health_check = gcp.compute.RegionHealthCheck("tcp-region-health-check",
    name="tcp-region-health-check",
    description="Health check via tcp",
    timeout_sec=1,
    check_interval_sec=1,
    healthy_threshold=4,
    unhealthy_threshold=5,
    tcp_health_check={
        "port_name": "health-check-port",
        "port_specification": "USE_NAMED_PORT",
        "request": "ARE YOU HEALTHY?",
        "proxy_header": "NONE",
        "response": "I AM HEALTHY",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var tcp_region_health_check = new Gcp.Compute.RegionHealthCheck("tcp-region-health-check", new()
    {
        Name = "tcp-region-health-check",
        Description = "Health check via tcp",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HealthyThreshold = 4,
        UnhealthyThreshold = 5,
        TcpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckTcpHealthCheckArgs
        {
            PortName = "health-check-port",
            PortSpecification = "USE_NAMED_PORT",
            Request = "ARE YOU HEALTHY?",
            ProxyHeader = "NONE",
            Response = "I AM HEALTHY",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "tcp-region-health-check", &compute.RegionHealthCheckArgs{
			Name:               pulumi.String("tcp-region-health-check"),
			Description:        pulumi.String("Health check via tcp"),
			TimeoutSec:         pulumi.Int(1),
			CheckIntervalSec:   pulumi.Int(1),
			HealthyThreshold:   pulumi.Int(4),
			UnhealthyThreshold: pulumi.Int(5),
			TcpHealthCheck: &compute.RegionHealthCheckTcpHealthCheckArgs{
				PortName:          pulumi.String("health-check-port"),
				PortSpecification: pulumi.String("USE_NAMED_PORT"),
				Request:           pulumi.String("ARE YOU HEALTHY?"),
				ProxyHeader:       pulumi.String("NONE"),
				Response:          pulumi.String("I AM HEALTHY"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckTcpHealthCheckArgs;
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 tcp_region_health_check = new RegionHealthCheck("tcp-region-health-check", RegionHealthCheckArgs.builder()
            .name("tcp-region-health-check")
            .description("Health check via tcp")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .healthyThreshold(4)
            .unhealthyThreshold(5)
            .tcpHealthCheck(RegionHealthCheckTcpHealthCheckArgs.builder()
                .portName("health-check-port")
                .portSpecification("USE_NAMED_PORT")
                .request("ARE YOU HEALTHY?")
                .proxyHeader("NONE")
                .response("I AM HEALTHY")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  tcp-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: tcp-region-health-check
      description: Health check via tcp
      timeoutSec: 1
      checkIntervalSec: 1
      healthyThreshold: 4
      unhealthyThreshold: 5
      tcpHealthCheck:
        portName: health-check-port
        portSpecification: USE_NAMED_PORT
        request: ARE YOU HEALTHY?
        proxyHeader: NONE
        response: I AM HEALTHY
Content copied to clipboard

Region Health Check Ssl

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const ssl_region_health_check = new gcp.compute.RegionHealthCheck("ssl-region-health-check", {
    name: "ssl-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    sslHealthCheck: {
        port: 443,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
ssl_region_health_check = gcp.compute.RegionHealthCheck("ssl-region-health-check",
    name="ssl-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    ssl_health_check={
        "port": 443,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var ssl_region_health_check = new Gcp.Compute.RegionHealthCheck("ssl-region-health-check", new()
    {
        Name = "ssl-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        SslHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckSslHealthCheckArgs
        {
            Port = 443,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "ssl-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("ssl-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			SslHealthCheck: &compute.RegionHealthCheckSslHealthCheckArgs{
				Port: pulumi.Int(443),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckSslHealthCheckArgs;
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 ssl_region_health_check = new RegionHealthCheck("ssl-region-health-check", RegionHealthCheckArgs.builder()
            .name("ssl-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .sslHealthCheck(RegionHealthCheckSslHealthCheckArgs.builder()
                .port(443)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  ssl-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: ssl-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      sslHealthCheck:
        port: '443'
Content copied to clipboard

Region Health Check Ssl Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const ssl_region_health_check = new gcp.compute.RegionHealthCheck("ssl-region-health-check", {
    name: "ssl-region-health-check",
    description: "Health check via ssl",
    timeoutSec: 1,
    checkIntervalSec: 1,
    healthyThreshold: 4,
    unhealthyThreshold: 5,
    sslHealthCheck: {
        portName: "health-check-port",
        portSpecification: "USE_NAMED_PORT",
        request: "ARE YOU HEALTHY?",
        proxyHeader: "NONE",
        response: "I AM HEALTHY",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
ssl_region_health_check = gcp.compute.RegionHealthCheck("ssl-region-health-check",
    name="ssl-region-health-check",
    description="Health check via ssl",
    timeout_sec=1,
    check_interval_sec=1,
    healthy_threshold=4,
    unhealthy_threshold=5,
    ssl_health_check={
        "port_name": "health-check-port",
        "port_specification": "USE_NAMED_PORT",
        "request": "ARE YOU HEALTHY?",
        "proxy_header": "NONE",
        "response": "I AM HEALTHY",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var ssl_region_health_check = new Gcp.Compute.RegionHealthCheck("ssl-region-health-check", new()
    {
        Name = "ssl-region-health-check",
        Description = "Health check via ssl",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HealthyThreshold = 4,
        UnhealthyThreshold = 5,
        SslHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckSslHealthCheckArgs
        {
            PortName = "health-check-port",
            PortSpecification = "USE_NAMED_PORT",
            Request = "ARE YOU HEALTHY?",
            ProxyHeader = "NONE",
            Response = "I AM HEALTHY",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "ssl-region-health-check", &compute.RegionHealthCheckArgs{
			Name:               pulumi.String("ssl-region-health-check"),
			Description:        pulumi.String("Health check via ssl"),
			TimeoutSec:         pulumi.Int(1),
			CheckIntervalSec:   pulumi.Int(1),
			HealthyThreshold:   pulumi.Int(4),
			UnhealthyThreshold: pulumi.Int(5),
			SslHealthCheck: &compute.RegionHealthCheckSslHealthCheckArgs{
				PortName:          pulumi.String("health-check-port"),
				PortSpecification: pulumi.String("USE_NAMED_PORT"),
				Request:           pulumi.String("ARE YOU HEALTHY?"),
				ProxyHeader:       pulumi.String("NONE"),
				Response:          pulumi.String("I AM HEALTHY"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckSslHealthCheckArgs;
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 ssl_region_health_check = new RegionHealthCheck("ssl-region-health-check", RegionHealthCheckArgs.builder()
            .name("ssl-region-health-check")
            .description("Health check via ssl")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .healthyThreshold(4)
            .unhealthyThreshold(5)
            .sslHealthCheck(RegionHealthCheckSslHealthCheckArgs.builder()
                .portName("health-check-port")
                .portSpecification("USE_NAMED_PORT")
                .request("ARE YOU HEALTHY?")
                .proxyHeader("NONE")
                .response("I AM HEALTHY")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  ssl-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: ssl-region-health-check
      description: Health check via ssl
      timeoutSec: 1
      checkIntervalSec: 1
      healthyThreshold: 4
      unhealthyThreshold: 5
      sslHealthCheck:
        portName: health-check-port
        portSpecification: USE_NAMED_PORT
        request: ARE YOU HEALTHY?
        proxyHeader: NONE
        response: I AM HEALTHY
Content copied to clipboard

Region Health Check Http

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const http_region_health_check = new gcp.compute.RegionHealthCheck("http-region-health-check", {
    name: "http-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    httpHealthCheck: {
        port: 80,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
http_region_health_check = gcp.compute.RegionHealthCheck("http-region-health-check",
    name="http-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    http_health_check={
        "port": 80,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var http_region_health_check = new Gcp.Compute.RegionHealthCheck("http-region-health-check", new()
    {
        Name = "http-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
        {
            Port = 80,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "http-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("http-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
				Port: pulumi.Int(80),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
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_region_health_check = new RegionHealthCheck("http-region-health-check", RegionHealthCheckArgs.builder()
            .name("http-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  http-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: http-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      httpHealthCheck:
        port: '80'
Content copied to clipboard

Region Health Check Http Logs

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const http_region_health_check = new gcp.compute.RegionHealthCheck("http-region-health-check", {
    name: "http-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    httpHealthCheck: {
        port: 80,
    },
    logConfig: {
        enable: true,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
http_region_health_check = gcp.compute.RegionHealthCheck("http-region-health-check",
    name="http-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    http_health_check={
        "port": 80,
    },
    log_config={
        "enable": True,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var http_region_health_check = new Gcp.Compute.RegionHealthCheck("http-region-health-check", new()
    {
        Name = "http-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
        {
            Port = 80,
        },
        LogConfig = new Gcp.Compute.Inputs.RegionHealthCheckLogConfigArgs
        {
            Enable = true,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "http-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("http-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
				Port: pulumi.Int(80),
			},
			LogConfig: &compute.RegionHealthCheckLogConfigArgs{
				Enable: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckLogConfigArgs;
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_region_health_check = new RegionHealthCheck("http-region-health-check", RegionHealthCheckArgs.builder()
            .name("http-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .logConfig(RegionHealthCheckLogConfigArgs.builder()
                .enable(true)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  http-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: http-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      httpHealthCheck:
        port: '80'
      logConfig:
        enable: true
Content copied to clipboard

Region Health Check Http Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const http_region_health_check = new gcp.compute.RegionHealthCheck("http-region-health-check", {
    name: "http-region-health-check",
    description: "Health check via http",
    timeoutSec: 1,
    checkIntervalSec: 1,
    healthyThreshold: 4,
    unhealthyThreshold: 5,
    httpHealthCheck: {
        portName: "health-check-port",
        portSpecification: "USE_NAMED_PORT",
        host: "1.2.3.4",
        requestPath: "/mypath",
        proxyHeader: "NONE",
        response: "I AM HEALTHY",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
http_region_health_check = gcp.compute.RegionHealthCheck("http-region-health-check",
    name="http-region-health-check",
    description="Health check via http",
    timeout_sec=1,
    check_interval_sec=1,
    healthy_threshold=4,
    unhealthy_threshold=5,
    http_health_check={
        "port_name": "health-check-port",
        "port_specification": "USE_NAMED_PORT",
        "host": "1.2.3.4",
        "request_path": "/mypath",
        "proxy_header": "NONE",
        "response": "I AM HEALTHY",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var http_region_health_check = new Gcp.Compute.RegionHealthCheck("http-region-health-check", new()
    {
        Name = "http-region-health-check",
        Description = "Health check via http",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HealthyThreshold = 4,
        UnhealthyThreshold = 5,
        HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
        {
            PortName = "health-check-port",
            PortSpecification = "USE_NAMED_PORT",
            Host = "1.2.3.4",
            RequestPath = "/mypath",
            ProxyHeader = "NONE",
            Response = "I AM HEALTHY",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "http-region-health-check", &compute.RegionHealthCheckArgs{
			Name:               pulumi.String("http-region-health-check"),
			Description:        pulumi.String("Health check via http"),
			TimeoutSec:         pulumi.Int(1),
			CheckIntervalSec:   pulumi.Int(1),
			HealthyThreshold:   pulumi.Int(4),
			UnhealthyThreshold: pulumi.Int(5),
			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
				PortName:          pulumi.String("health-check-port"),
				PortSpecification: pulumi.String("USE_NAMED_PORT"),
				Host:              pulumi.String("1.2.3.4"),
				RequestPath:       pulumi.String("/mypath"),
				ProxyHeader:       pulumi.String("NONE"),
				Response:          pulumi.String("I AM HEALTHY"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
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_region_health_check = new RegionHealthCheck("http-region-health-check", RegionHealthCheckArgs.builder()
            .name("http-region-health-check")
            .description("Health check via http")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .healthyThreshold(4)
            .unhealthyThreshold(5)
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .portName("health-check-port")
                .portSpecification("USE_NAMED_PORT")
                .host("1.2.3.4")
                .requestPath("/mypath")
                .proxyHeader("NONE")
                .response("I AM HEALTHY")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  http-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: http-region-health-check
      description: Health check via http
      timeoutSec: 1
      checkIntervalSec: 1
      healthyThreshold: 4
      unhealthyThreshold: 5
      httpHealthCheck:
        portName: health-check-port
        portSpecification: USE_NAMED_PORT
        host: 1.2.3.4
        requestPath: /mypath
        proxyHeader: NONE
        response: I AM HEALTHY
Content copied to clipboard

Region Health Check Https

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const https_region_health_check = new gcp.compute.RegionHealthCheck("https-region-health-check", {
    name: "https-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    httpsHealthCheck: {
        port: 443,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
https_region_health_check = gcp.compute.RegionHealthCheck("https-region-health-check",
    name="https-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    https_health_check={
        "port": 443,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var https_region_health_check = new Gcp.Compute.RegionHealthCheck("https-region-health-check", new()
    {
        Name = "https-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HttpsHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpsHealthCheckArgs
        {
            Port = 443,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "https-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("https-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			HttpsHealthCheck: &compute.RegionHealthCheckHttpsHealthCheckArgs{
				Port: pulumi.Int(443),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpsHealthCheckArgs;
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_region_health_check = new RegionHealthCheck("https-region-health-check", RegionHealthCheckArgs.builder()
            .name("https-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .httpsHealthCheck(RegionHealthCheckHttpsHealthCheckArgs.builder()
                .port(443)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  https-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: https-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      httpsHealthCheck:
        port: '443'
Content copied to clipboard

Region Health Check Https Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const https_region_health_check = new gcp.compute.RegionHealthCheck("https-region-health-check", {
    name: "https-region-health-check",
    description: "Health check via https",
    timeoutSec: 1,
    checkIntervalSec: 1,
    healthyThreshold: 4,
    unhealthyThreshold: 5,
    httpsHealthCheck: {
        portName: "health-check-port",
        portSpecification: "USE_NAMED_PORT",
        host: "1.2.3.4",
        requestPath: "/mypath",
        proxyHeader: "NONE",
        response: "I AM HEALTHY",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
https_region_health_check = gcp.compute.RegionHealthCheck("https-region-health-check",
    name="https-region-health-check",
    description="Health check via https",
    timeout_sec=1,
    check_interval_sec=1,
    healthy_threshold=4,
    unhealthy_threshold=5,
    https_health_check={
        "port_name": "health-check-port",
        "port_specification": "USE_NAMED_PORT",
        "host": "1.2.3.4",
        "request_path": "/mypath",
        "proxy_header": "NONE",
        "response": "I AM HEALTHY",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var https_region_health_check = new Gcp.Compute.RegionHealthCheck("https-region-health-check", new()
    {
        Name = "https-region-health-check",
        Description = "Health check via https",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HealthyThreshold = 4,
        UnhealthyThreshold = 5,
        HttpsHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpsHealthCheckArgs
        {
            PortName = "health-check-port",
            PortSpecification = "USE_NAMED_PORT",
            Host = "1.2.3.4",
            RequestPath = "/mypath",
            ProxyHeader = "NONE",
            Response = "I AM HEALTHY",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "https-region-health-check", &compute.RegionHealthCheckArgs{
			Name:               pulumi.String("https-region-health-check"),
			Description:        pulumi.String("Health check via https"),
			TimeoutSec:         pulumi.Int(1),
			CheckIntervalSec:   pulumi.Int(1),
			HealthyThreshold:   pulumi.Int(4),
			UnhealthyThreshold: pulumi.Int(5),
			HttpsHealthCheck: &compute.RegionHealthCheckHttpsHealthCheckArgs{
				PortName:          pulumi.String("health-check-port"),
				PortSpecification: pulumi.String("USE_NAMED_PORT"),
				Host:              pulumi.String("1.2.3.4"),
				RequestPath:       pulumi.String("/mypath"),
				ProxyHeader:       pulumi.String("NONE"),
				Response:          pulumi.String("I AM HEALTHY"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpsHealthCheckArgs;
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_region_health_check = new RegionHealthCheck("https-region-health-check", RegionHealthCheckArgs.builder()
            .name("https-region-health-check")
            .description("Health check via https")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .healthyThreshold(4)
            .unhealthyThreshold(5)
            .httpsHealthCheck(RegionHealthCheckHttpsHealthCheckArgs.builder()
                .portName("health-check-port")
                .portSpecification("USE_NAMED_PORT")
                .host("1.2.3.4")
                .requestPath("/mypath")
                .proxyHeader("NONE")
                .response("I AM HEALTHY")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  https-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: https-region-health-check
      description: Health check via https
      timeoutSec: 1
      checkIntervalSec: 1
      healthyThreshold: 4
      unhealthyThreshold: 5
      httpsHealthCheck:
        portName: health-check-port
        portSpecification: USE_NAMED_PORT
        host: 1.2.3.4
        requestPath: /mypath
        proxyHeader: NONE
        response: I AM HEALTHY
Content copied to clipboard

Region Health Check Http2

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const http2_region_health_check = new gcp.compute.RegionHealthCheck("http2-region-health-check", {
    name: "http2-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    http2HealthCheck: {
        port: 443,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
http2_region_health_check = gcp.compute.RegionHealthCheck("http2-region-health-check",
    name="http2-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    http2_health_check={
        "port": 443,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var http2_region_health_check = new Gcp.Compute.RegionHealthCheck("http2-region-health-check", new()
    {
        Name = "http2-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        Http2HealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttp2HealthCheckArgs
        {
            Port = 443,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "http2-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("http2-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			Http2HealthCheck: &compute.RegionHealthCheckHttp2HealthCheckArgs{
				Port: pulumi.Int(443),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttp2HealthCheckArgs;
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 http2_region_health_check = new RegionHealthCheck("http2-region-health-check", RegionHealthCheckArgs.builder()
            .name("http2-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .http2HealthCheck(RegionHealthCheckHttp2HealthCheckArgs.builder()
                .port(443)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  http2-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: http2-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      http2HealthCheck:
        port: '443'
Content copied to clipboard

Region Health Check Http2 Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const http2_region_health_check = new gcp.compute.RegionHealthCheck("http2-region-health-check", {
    name: "http2-region-health-check",
    description: "Health check via http2",
    timeoutSec: 1,
    checkIntervalSec: 1,
    healthyThreshold: 4,
    unhealthyThreshold: 5,
    http2HealthCheck: {
        portName: "health-check-port",
        portSpecification: "USE_NAMED_PORT",
        host: "1.2.3.4",
        requestPath: "/mypath",
        proxyHeader: "NONE",
        response: "I AM HEALTHY",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
http2_region_health_check = gcp.compute.RegionHealthCheck("http2-region-health-check",
    name="http2-region-health-check",
    description="Health check via http2",
    timeout_sec=1,
    check_interval_sec=1,
    healthy_threshold=4,
    unhealthy_threshold=5,
    http2_health_check={
        "port_name": "health-check-port",
        "port_specification": "USE_NAMED_PORT",
        "host": "1.2.3.4",
        "request_path": "/mypath",
        "proxy_header": "NONE",
        "response": "I AM HEALTHY",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var http2_region_health_check = new Gcp.Compute.RegionHealthCheck("http2-region-health-check", new()
    {
        Name = "http2-region-health-check",
        Description = "Health check via http2",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HealthyThreshold = 4,
        UnhealthyThreshold = 5,
        Http2HealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttp2HealthCheckArgs
        {
            PortName = "health-check-port",
            PortSpecification = "USE_NAMED_PORT",
            Host = "1.2.3.4",
            RequestPath = "/mypath",
            ProxyHeader = "NONE",
            Response = "I AM HEALTHY",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "http2-region-health-check", &compute.RegionHealthCheckArgs{
			Name:               pulumi.String("http2-region-health-check"),
			Description:        pulumi.String("Health check via http2"),
			TimeoutSec:         pulumi.Int(1),
			CheckIntervalSec:   pulumi.Int(1),
			HealthyThreshold:   pulumi.Int(4),
			UnhealthyThreshold: pulumi.Int(5),
			Http2HealthCheck: &compute.RegionHealthCheckHttp2HealthCheckArgs{
				PortName:          pulumi.String("health-check-port"),
				PortSpecification: pulumi.String("USE_NAMED_PORT"),
				Host:              pulumi.String("1.2.3.4"),
				RequestPath:       pulumi.String("/mypath"),
				ProxyHeader:       pulumi.String("NONE"),
				Response:          pulumi.String("I AM HEALTHY"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttp2HealthCheckArgs;
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 http2_region_health_check = new RegionHealthCheck("http2-region-health-check", RegionHealthCheckArgs.builder()
            .name("http2-region-health-check")
            .description("Health check via http2")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .healthyThreshold(4)
            .unhealthyThreshold(5)
            .http2HealthCheck(RegionHealthCheckHttp2HealthCheckArgs.builder()
                .portName("health-check-port")
                .portSpecification("USE_NAMED_PORT")
                .host("1.2.3.4")
                .requestPath("/mypath")
                .proxyHeader("NONE")
                .response("I AM HEALTHY")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  http2-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: http2-region-health-check
      description: Health check via http2
      timeoutSec: 1
      checkIntervalSec: 1
      healthyThreshold: 4
      unhealthyThreshold: 5
      http2HealthCheck:
        portName: health-check-port
        portSpecification: USE_NAMED_PORT
        host: 1.2.3.4
        requestPath: /mypath
        proxyHeader: NONE
        response: I AM HEALTHY
Content copied to clipboard

Region Health Check Grpc

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const grpc_region_health_check = new gcp.compute.RegionHealthCheck("grpc-region-health-check", {
    name: "grpc-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    grpcHealthCheck: {
        port: 443,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
grpc_region_health_check = gcp.compute.RegionHealthCheck("grpc-region-health-check",
    name="grpc-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    grpc_health_check={
        "port": 443,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var grpc_region_health_check = new Gcp.Compute.RegionHealthCheck("grpc-region-health-check", new()
    {
        Name = "grpc-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        GrpcHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckGrpcHealthCheckArgs
        {
            Port = 443,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "grpc-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("grpc-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			GrpcHealthCheck: &compute.RegionHealthCheckGrpcHealthCheckArgs{
				Port: pulumi.Int(443),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckGrpcHealthCheckArgs;
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 grpc_region_health_check = new RegionHealthCheck("grpc-region-health-check", RegionHealthCheckArgs.builder()
            .name("grpc-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .grpcHealthCheck(RegionHealthCheckGrpcHealthCheckArgs.builder()
                .port(443)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  grpc-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: grpc-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      grpcHealthCheck:
        port: '443'
Content copied to clipboard

Region Health Check Grpc Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const grpc_region_health_check = new gcp.compute.RegionHealthCheck("grpc-region-health-check", {
    name: "grpc-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    grpcHealthCheck: {
        portName: "health-check-port",
        portSpecification: "USE_NAMED_PORT",
        grpcServiceName: "testservice",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
grpc_region_health_check = gcp.compute.RegionHealthCheck("grpc-region-health-check",
    name="grpc-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    grpc_health_check={
        "port_name": "health-check-port",
        "port_specification": "USE_NAMED_PORT",
        "grpc_service_name": "testservice",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var grpc_region_health_check = new Gcp.Compute.RegionHealthCheck("grpc-region-health-check", new()
    {
        Name = "grpc-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        GrpcHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckGrpcHealthCheckArgs
        {
            PortName = "health-check-port",
            PortSpecification = "USE_NAMED_PORT",
            GrpcServiceName = "testservice",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "grpc-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("grpc-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			GrpcHealthCheck: &compute.RegionHealthCheckGrpcHealthCheckArgs{
				PortName:          pulumi.String("health-check-port"),
				PortSpecification: pulumi.String("USE_NAMED_PORT"),
				GrpcServiceName:   pulumi.String("testservice"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckGrpcHealthCheckArgs;
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 grpc_region_health_check = new RegionHealthCheck("grpc-region-health-check", RegionHealthCheckArgs.builder()
            .name("grpc-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .grpcHealthCheck(RegionHealthCheckGrpcHealthCheckArgs.builder()
                .portName("health-check-port")
                .portSpecification("USE_NAMED_PORT")
                .grpcServiceName("testservice")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  grpc-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: grpc-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      grpcHealthCheck:
        portName: health-check-port
        portSpecification: USE_NAMED_PORT
        grpcServiceName: testservice
Content copied to clipboard

Region Health Check Grpc With Tls

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const grpc_with_tls_region_health_check = new gcp.compute.RegionHealthCheck("grpc-with-tls-region-health-check", {
    name: "grpc-with-tls-region-health-check",
    timeoutSec: 1,
    checkIntervalSec: 1,
    grpcTlsHealthCheck: {
        port: 443,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
grpc_with_tls_region_health_check = gcp.compute.RegionHealthCheck("grpc-with-tls-region-health-check",
    name="grpc-with-tls-region-health-check",
    timeout_sec=1,
    check_interval_sec=1,
    grpc_tls_health_check={
        "port": 443,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var grpc_with_tls_region_health_check = new Gcp.Compute.RegionHealthCheck("grpc-with-tls-region-health-check", new()
    {
        Name = "grpc-with-tls-region-health-check",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        GrpcTlsHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckGrpcTlsHealthCheckArgs
        {
            Port = 443,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "grpc-with-tls-region-health-check", &compute.RegionHealthCheckArgs{
			Name:             pulumi.String("grpc-with-tls-region-health-check"),
			TimeoutSec:       pulumi.Int(1),
			CheckIntervalSec: pulumi.Int(1),
			GrpcTlsHealthCheck: &compute.RegionHealthCheckGrpcTlsHealthCheckArgs{
				Port: pulumi.Int(443),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckGrpcTlsHealthCheckArgs;
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 grpc_with_tls_region_health_check = new RegionHealthCheck("grpc-with-tls-region-health-check", RegionHealthCheckArgs.builder()
            .name("grpc-with-tls-region-health-check")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .grpcTlsHealthCheck(RegionHealthCheckGrpcTlsHealthCheckArgs.builder()
                .port(443)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  grpc-with-tls-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: grpc-with-tls-region-health-check
      timeoutSec: 1
      checkIntervalSec: 1
      grpcTlsHealthCheck:
        port: '443'
Content copied to clipboard

Region Health Check Grpc With Tls Full

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const grpc_with_tls_region_health_check = new gcp.compute.RegionHealthCheck("grpc-with-tls-region-health-check", {
    name: "grpc-with-tls-region-health-check",
    description: "regional health check via GRPC with TLS",
    timeoutSec: 1,
    checkIntervalSec: 1,
    healthyThreshold: 4,
    unhealthyThreshold: 5,
    grpcTlsHealthCheck: {
        portSpecification: "USE_FIXED_PORT",
        port: 443,
        grpcServiceName: "testservice",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
grpc_with_tls_region_health_check = gcp.compute.RegionHealthCheck("grpc-with-tls-region-health-check",
    name="grpc-with-tls-region-health-check",
    description="regional health check via GRPC with TLS",
    timeout_sec=1,
    check_interval_sec=1,
    healthy_threshold=4,
    unhealthy_threshold=5,
    grpc_tls_health_check={
        "port_specification": "USE_FIXED_PORT",
        "port": 443,
        "grpc_service_name": "testservice",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var grpc_with_tls_region_health_check = new Gcp.Compute.RegionHealthCheck("grpc-with-tls-region-health-check", new()
    {
        Name = "grpc-with-tls-region-health-check",
        Description = "regional health check via GRPC with TLS",
        TimeoutSec = 1,
        CheckIntervalSec = 1,
        HealthyThreshold = 4,
        UnhealthyThreshold = 5,
        GrpcTlsHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckGrpcTlsHealthCheckArgs
        {
            PortSpecification = "USE_FIXED_PORT",
            Port = 443,
            GrpcServiceName = "testservice",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewRegionHealthCheck(ctx, "grpc-with-tls-region-health-check", &compute.RegionHealthCheckArgs{
			Name:               pulumi.String("grpc-with-tls-region-health-check"),
			Description:        pulumi.String("regional health check via GRPC with TLS"),
			TimeoutSec:         pulumi.Int(1),
			CheckIntervalSec:   pulumi.Int(1),
			HealthyThreshold:   pulumi.Int(4),
			UnhealthyThreshold: pulumi.Int(5),
			GrpcTlsHealthCheck: &compute.RegionHealthCheckGrpcTlsHealthCheckArgs{
				PortSpecification: pulumi.String("USE_FIXED_PORT"),
				Port:              pulumi.Int(443),
				GrpcServiceName:   pulumi.String("testservice"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckGrpcTlsHealthCheckArgs;
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 grpc_with_tls_region_health_check = new RegionHealthCheck("grpc-with-tls-region-health-check", RegionHealthCheckArgs.builder()
            .name("grpc-with-tls-region-health-check")
            .description("regional health check via GRPC with TLS")
            .timeoutSec(1)
            .checkIntervalSec(1)
            .healthyThreshold(4)
            .unhealthyThreshold(5)
            .grpcTlsHealthCheck(RegionHealthCheckGrpcTlsHealthCheckArgs.builder()
                .portSpecification("USE_FIXED_PORT")
                .port(443)
                .grpcServiceName("testservice")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  grpc-with-tls-region-health-check:
    type: gcp:compute:RegionHealthCheck
    properties:
      name: grpc-with-tls-region-health-check
      description: regional health check via GRPC with TLS
      timeoutSec: 1
      checkIntervalSec: 1
      healthyThreshold: 4
      unhealthyThreshold: 5
      grpcTlsHealthCheck:
        portSpecification: USE_FIXED_PORT
        port: '443'
        grpcServiceName: testservice
Content copied to clipboard

Import

RegionHealthCheck can be imported using any of these accepted formats:

  • projects/{{project}}/regions/{{region}}/healthChecks/{{name}}

  • {{project}}/{{region}}/{{name}}

  • {{region}}/{{name}}

  • {{name}} When using the pulumi import command, RegionHealthCheck can be imported using one of the formats above. For example:

$ pulumi import gcp:compute/regionHealthCheck:RegionHealthCheck default projects/{{project}}/regions/{{region}}/healthChecks/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/regionHealthCheck:RegionHealthCheck default {{project}}/{{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/regionHealthCheck:RegionHealthCheck default {{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/regionHealthCheck:RegionHealthCheck default {{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(checkIntervalSec: Output<Int>? = null, description: Output<String>? = null, grpcHealthCheck: Output<RegionHealthCheckGrpcHealthCheckArgs>? = null, grpcTlsHealthCheck: Output<RegionHealthCheckGrpcTlsHealthCheckArgs>? = null, healthyThreshold: Output<Int>? = null, http2HealthCheck: Output<RegionHealthCheckHttp2HealthCheckArgs>? = null, httpHealthCheck: Output<RegionHealthCheckHttpHealthCheckArgs>? = null, httpsHealthCheck: Output<RegionHealthCheckHttpsHealthCheckArgs>? = null, logConfig: Output<RegionHealthCheckLogConfigArgs>? = null, name: Output<String>? = null, project: Output<String>? = null, region: Output<String>? = null, sslHealthCheck: Output<RegionHealthCheckSslHealthCheckArgs>? = null, tcpHealthCheck: Output<RegionHealthCheckTcpHealthCheckArgs>? = null, timeoutSec: Output<Int>? = null, unhealthyThreshold: Output<Int>? = null)

Properties

Link copied to clipboard
val checkIntervalSec: Output<Int>? = null

How often (in seconds) to send a health check. The default value is 5 seconds.

Link copied to clipboard
val description: Output<String>? = null

An optional description of this resource. Provide this property when you create the resource.

Link copied to clipboard
val grpcHealthCheck: Output<RegionHealthCheckGrpcHealthCheckArgs>? = null

A nested object resource. Structure is documented below.

Link copied to clipboard
val grpcTlsHealthCheck: Output<RegionHealthCheckGrpcTlsHealthCheckArgs>? = null

A nested object resource. Structure is documented below.

Link copied to clipboard
val healthyThreshold: Output<Int>? = null

A so-far unhealthy instance will be marked healthy after this many consecutive successes. The default value is 2.

Link copied to clipboard
val http2HealthCheck: Output<RegionHealthCheckHttp2HealthCheckArgs>? = null

A nested object resource. Structure is documented below.

Link copied to clipboard
val httpHealthCheck: Output<RegionHealthCheckHttpHealthCheckArgs>? = null

A nested object resource. Structure is documented below.

Link copied to clipboard
val httpsHealthCheck: Output<RegionHealthCheckHttpsHealthCheckArgs>? = null

A nested object resource. Structure is documented below.

Link copied to clipboard
val logConfig: Output<RegionHealthCheckLogConfigArgs>? = null

Configure logging on this health check. Structure is documented below.

Link copied to clipboard
val name: Output<String>? = null

Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.

Link copied to clipboard
val project: Output<String>? = null

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

Link copied to clipboard
val region: Output<String>? = null

The Region in which the created health check should reside. If it is not provided, the provider region is used.

Link copied to clipboard
val sslHealthCheck: Output<RegionHealthCheckSslHealthCheckArgs>? = null

A nested object resource. Structure is documented below.

Link copied to clipboard
val tcpHealthCheck: Output<RegionHealthCheckTcpHealthCheckArgs>? = null

A nested object resource. Structure is documented below.

Link copied to clipboard
val timeoutSec: Output<Int>? = null

How long (in seconds) to wait before claiming failure. The default value is 5 seconds. It is invalid for timeoutSec to have greater value than checkIntervalSec.

Link copied to clipboard
val unhealthyThreshold: Output<Int>? = null

A so-far healthy instance will be marked unhealthy after this many consecutive failures. The default value is 2.

Functions

Link copied to clipboard
open override fun toJava(): RegionHealthCheckArgs