Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Google Cloud Native
  3. API Docs
  4. compute
  5. compute/beta
  6. RegionHealthCheck

Google Cloud Native is in preview. Google Cloud Classic is fully supported.

Google Cloud Native v0.32.0 published on Wednesday, Nov 29, 2023 by Pulumi
pulumi/pulumi-google-native

google-native.compute/beta.RegionHealthCheck

Explore with Pulumi AI

Google Cloud Native is in preview. Google Cloud Classic is fully supported.

Google Cloud Native v0.32.0 published on Wednesday, Nov 29, 2023 by Pulumi
pulumi/pulumi-google-native

Creates a HealthCheck resource in the specified project using the data included in the request.

Create RegionHealthCheck Resource

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

Constructor syntax

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

@overload
def RegionHealthCheck(resource_name: str,
                      opts: Optional[ResourceOptions] = None,
                      region: Optional[str] = None,
                      log_config: Optional[HealthCheckLogConfigArgs] = None,
                      http_health_check: Optional[HTTPHealthCheckArgs] = None,
                      name: Optional[str] = None,
                      http2_health_check: Optional[HTTP2HealthCheckArgs] = None,
                      project: Optional[str] = None,
                      https_health_check: Optional[HTTPSHealthCheckArgs] = None,
                      kind: Optional[str] = None,
                      description: Optional[str] = None,
                      healthy_threshold: Optional[int] = None,
                      grpc_health_check: Optional[GRPCHealthCheckArgs] = None,
                      check_interval_sec: Optional[int] = None,
                      request_id: Optional[str] = None,
                      ssl_health_check: Optional[SSLHealthCheckArgs] = None,
                      tcp_health_check: Optional[TCPHealthCheckArgs] = None,
                      timeout_sec: Optional[int] = None,
                      type: Optional[RegionHealthCheckType] = None,
                      unhealthy_threshold: Optional[int] = None)
func NewRegionHealthCheck(ctx *Context, name string, args RegionHealthCheckArgs, opts ...ResourceOption) (*RegionHealthCheck, error)
public RegionHealthCheck(string name, RegionHealthCheckArgs args, CustomResourceOptions? opts = null)
public RegionHealthCheck(String name, RegionHealthCheckArgs args)
public RegionHealthCheck(String name, RegionHealthCheckArgs args, CustomResourceOptions options)

type: google-native:compute/beta:RegionHealthCheck
properties: # The arguments to resource properties.
options: # Bag of options to control resource's behavior.

Parameters

name This property is required. string
The unique name of the resource.
args This property is required. RegionHealthCheckArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
resource_name This property is required. str
The unique name of the resource.
args This property is required. RegionHealthCheckArgs
The arguments to resource properties.
opts ResourceOptions
Bag of options to control resource's behavior.
ctx Context
Context object for the current deployment.
name This property is required. string
The unique name of the resource.
args This property is required. RegionHealthCheckArgs
The arguments to resource properties.
opts ResourceOption
Bag of options to control resource's behavior.
name This property is required. string
The unique name of the resource.
args This property is required. RegionHealthCheckArgs
The arguments to resource properties.
opts CustomResourceOptions
Bag of options to control resource's behavior.
name This property is required. String
The unique name of the resource.
args This property is required. RegionHealthCheckArgs
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 google_nativeRegionHealthCheckResource = new GoogleNative.Compute.Beta.RegionHealthCheck("google-nativeRegionHealthCheckResource", new()
{
    Region = "string",
    LogConfig = new GoogleNative.Compute.Beta.Inputs.HealthCheckLogConfigArgs
    {
        Enable = false,
    },
    HttpHealthCheck = new GoogleNative.Compute.Beta.Inputs.HTTPHealthCheckArgs
    {
        Host = "string",
        Port = 0,
        PortName = "string",
        PortSpecification = GoogleNative.Compute.Beta.HTTPHealthCheckPortSpecification.UseFixedPort,
        ProxyHeader = GoogleNative.Compute.Beta.HTTPHealthCheckProxyHeader.None,
        RequestPath = "string",
        Response = "string",
    },
    Name = "string",
    Http2HealthCheck = new GoogleNative.Compute.Beta.Inputs.HTTP2HealthCheckArgs
    {
        Host = "string",
        Port = 0,
        PortName = "string",
        PortSpecification = GoogleNative.Compute.Beta.HTTP2HealthCheckPortSpecification.UseFixedPort,
        ProxyHeader = GoogleNative.Compute.Beta.HTTP2HealthCheckProxyHeader.None,
        RequestPath = "string",
        Response = "string",
    },
    Project = "string",
    HttpsHealthCheck = new GoogleNative.Compute.Beta.Inputs.HTTPSHealthCheckArgs
    {
        Host = "string",
        Port = 0,
        PortName = "string",
        PortSpecification = GoogleNative.Compute.Beta.HTTPSHealthCheckPortSpecification.UseFixedPort,
        ProxyHeader = GoogleNative.Compute.Beta.HTTPSHealthCheckProxyHeader.None,
        RequestPath = "string",
        Response = "string",
    },
    Kind = "string",
    Description = "string",
    HealthyThreshold = 0,
    GrpcHealthCheck = new GoogleNative.Compute.Beta.Inputs.GRPCHealthCheckArgs
    {
        GrpcServiceName = "string",
        Port = 0,
        PortName = "string",
        PortSpecification = GoogleNative.Compute.Beta.GRPCHealthCheckPortSpecification.UseFixedPort,
    },
    CheckIntervalSec = 0,
    RequestId = "string",
    SslHealthCheck = new GoogleNative.Compute.Beta.Inputs.SSLHealthCheckArgs
    {
        Port = 0,
        PortName = "string",
        PortSpecification = GoogleNative.Compute.Beta.SSLHealthCheckPortSpecification.UseFixedPort,
        ProxyHeader = GoogleNative.Compute.Beta.SSLHealthCheckProxyHeader.None,
        Request = "string",
        Response = "string",
    },
    TcpHealthCheck = new GoogleNative.Compute.Beta.Inputs.TCPHealthCheckArgs
    {
        Port = 0,
        PortName = "string",
        PortSpecification = GoogleNative.Compute.Beta.TCPHealthCheckPortSpecification.UseFixedPort,
        ProxyHeader = GoogleNative.Compute.Beta.TCPHealthCheckProxyHeader.None,
        Request = "string",
        Response = "string",
    },
    TimeoutSec = 0,
    Type = GoogleNative.Compute.Beta.RegionHealthCheckType.Grpc,
    UnhealthyThreshold = 0,
});
Copy
example, err := computebeta.NewRegionHealthCheck(ctx, "google-nativeRegionHealthCheckResource", &computebeta.RegionHealthCheckArgs{
	Region: pulumi.String("string"),
	LogConfig: &compute.HealthCheckLogConfigArgs{
		Enable: pulumi.Bool(false),
	},
	HttpHealthCheck: &compute.HTTPHealthCheckTypeArgs{
		Host:              pulumi.String("string"),
		Port:              pulumi.Int(0),
		PortName:          pulumi.String("string"),
		PortSpecification: computebeta.HTTPHealthCheckPortSpecificationUseFixedPort,
		ProxyHeader:       computebeta.HTTPHealthCheckProxyHeaderNone,
		RequestPath:       pulumi.String("string"),
		Response:          pulumi.String("string"),
	},
	Name: pulumi.String("string"),
	Http2HealthCheck: &compute.HTTP2HealthCheckArgs{
		Host:              pulumi.String("string"),
		Port:              pulumi.Int(0),
		PortName:          pulumi.String("string"),
		PortSpecification: computebeta.HTTP2HealthCheckPortSpecificationUseFixedPort,
		ProxyHeader:       computebeta.HTTP2HealthCheckProxyHeaderNone,
		RequestPath:       pulumi.String("string"),
		Response:          pulumi.String("string"),
	},
	Project: pulumi.String("string"),
	HttpsHealthCheck: &compute.HTTPSHealthCheckTypeArgs{
		Host:              pulumi.String("string"),
		Port:              pulumi.Int(0),
		PortName:          pulumi.String("string"),
		PortSpecification: computebeta.HTTPSHealthCheckPortSpecificationUseFixedPort,
		ProxyHeader:       computebeta.HTTPSHealthCheckProxyHeaderNone,
		RequestPath:       pulumi.String("string"),
		Response:          pulumi.String("string"),
	},
	Kind:             pulumi.String("string"),
	Description:      pulumi.String("string"),
	HealthyThreshold: pulumi.Int(0),
	GrpcHealthCheck: &compute.GRPCHealthCheckArgs{
		GrpcServiceName:   pulumi.String("string"),
		Port:              pulumi.Int(0),
		PortName:          pulumi.String("string"),
		PortSpecification: computebeta.GRPCHealthCheckPortSpecificationUseFixedPort,
	},
	CheckIntervalSec: pulumi.Int(0),
	RequestId:        pulumi.String("string"),
	SslHealthCheck: &compute.SSLHealthCheckArgs{
		Port:              pulumi.Int(0),
		PortName:          pulumi.String("string"),
		PortSpecification: computebeta.SSLHealthCheckPortSpecificationUseFixedPort,
		ProxyHeader:       computebeta.SSLHealthCheckProxyHeaderNone,
		Request:           pulumi.String("string"),
		Response:          pulumi.String("string"),
	},
	TcpHealthCheck: &compute.TCPHealthCheckArgs{
		Port:              pulumi.Int(0),
		PortName:          pulumi.String("string"),
		PortSpecification: computebeta.TCPHealthCheckPortSpecificationUseFixedPort,
		ProxyHeader:       computebeta.TCPHealthCheckProxyHeaderNone,
		Request:           pulumi.String("string"),
		Response:          pulumi.String("string"),
	},
	TimeoutSec:         pulumi.Int(0),
	Type:               computebeta.RegionHealthCheckTypeGrpc,
	UnhealthyThreshold: pulumi.Int(0),
})
Copy
var google_nativeRegionHealthCheckResource = new RegionHealthCheck("google-nativeRegionHealthCheckResource", RegionHealthCheckArgs.builder()
    .region("string")
    .logConfig(HealthCheckLogConfigArgs.builder()
        .enable(false)
        .build())
    .httpHealthCheck(HTTPHealthCheckArgs.builder()
        .host("string")
        .port(0)
        .portName("string")
        .portSpecification("USE_FIXED_PORT")
        .proxyHeader("NONE")
        .requestPath("string")
        .response("string")
        .build())
    .name("string")
    .http2HealthCheck(HTTP2HealthCheckArgs.builder()
        .host("string")
        .port(0)
        .portName("string")
        .portSpecification("USE_FIXED_PORT")
        .proxyHeader("NONE")
        .requestPath("string")
        .response("string")
        .build())
    .project("string")
    .httpsHealthCheck(HTTPSHealthCheckArgs.builder()
        .host("string")
        .port(0)
        .portName("string")
        .portSpecification("USE_FIXED_PORT")
        .proxyHeader("NONE")
        .requestPath("string")
        .response("string")
        .build())
    .kind("string")
    .description("string")
    .healthyThreshold(0)
    .grpcHealthCheck(GRPCHealthCheckArgs.builder()
        .grpcServiceName("string")
        .port(0)
        .portName("string")
        .portSpecification("USE_FIXED_PORT")
        .build())
    .checkIntervalSec(0)
    .requestId("string")
    .sslHealthCheck(SSLHealthCheckArgs.builder()
        .port(0)
        .portName("string")
        .portSpecification("USE_FIXED_PORT")
        .proxyHeader("NONE")
        .request("string")
        .response("string")
        .build())
    .tcpHealthCheck(TCPHealthCheckArgs.builder()
        .port(0)
        .portName("string")
        .portSpecification("USE_FIXED_PORT")
        .proxyHeader("NONE")
        .request("string")
        .response("string")
        .build())
    .timeoutSec(0)
    .type("GRPC")
    .unhealthyThreshold(0)
    .build());
Copy
google_native_region_health_check_resource = google_native.compute.beta.RegionHealthCheck("google-nativeRegionHealthCheckResource",
    region="string",
    log_config={
        "enable": False,
    },
    http_health_check={
        "host": "string",
        "port": 0,
        "port_name": "string",
        "port_specification": google_native.compute.beta.HTTPHealthCheckPortSpecification.USE_FIXED_PORT,
        "proxy_header": google_native.compute.beta.HTTPHealthCheckProxyHeader.NONE,
        "request_path": "string",
        "response": "string",
    },
    name="string",
    http2_health_check={
        "host": "string",
        "port": 0,
        "port_name": "string",
        "port_specification": google_native.compute.beta.HTTP2HealthCheckPortSpecification.USE_FIXED_PORT,
        "proxy_header": google_native.compute.beta.HTTP2HealthCheckProxyHeader.NONE,
        "request_path": "string",
        "response": "string",
    },
    project="string",
    https_health_check={
        "host": "string",
        "port": 0,
        "port_name": "string",
        "port_specification": google_native.compute.beta.HTTPSHealthCheckPortSpecification.USE_FIXED_PORT,
        "proxy_header": google_native.compute.beta.HTTPSHealthCheckProxyHeader.NONE,
        "request_path": "string",
        "response": "string",
    },
    kind="string",
    description="string",
    healthy_threshold=0,
    grpc_health_check={
        "grpc_service_name": "string",
        "port": 0,
        "port_name": "string",
        "port_specification": google_native.compute.beta.GRPCHealthCheckPortSpecification.USE_FIXED_PORT,
    },
    check_interval_sec=0,
    request_id="string",
    ssl_health_check={
        "port": 0,
        "port_name": "string",
        "port_specification": google_native.compute.beta.SSLHealthCheckPortSpecification.USE_FIXED_PORT,
        "proxy_header": google_native.compute.beta.SSLHealthCheckProxyHeader.NONE,
        "request": "string",
        "response": "string",
    },
    tcp_health_check={
        "port": 0,
        "port_name": "string",
        "port_specification": google_native.compute.beta.TCPHealthCheckPortSpecification.USE_FIXED_PORT,
        "proxy_header": google_native.compute.beta.TCPHealthCheckProxyHeader.NONE,
        "request": "string",
        "response": "string",
    },
    timeout_sec=0,
    type=google_native.compute.beta.RegionHealthCheckType.GRPC,
    unhealthy_threshold=0)
Copy
const google_nativeRegionHealthCheckResource = new google_native.compute.beta.RegionHealthCheck("google-nativeRegionHealthCheckResource", {
    region: "string",
    logConfig: {
        enable: false,
    },
    httpHealthCheck: {
        host: "string",
        port: 0,
        portName: "string",
        portSpecification: google_native.compute.beta.HTTPHealthCheckPortSpecification.UseFixedPort,
        proxyHeader: google_native.compute.beta.HTTPHealthCheckProxyHeader.None,
        requestPath: "string",
        response: "string",
    },
    name: "string",
    http2HealthCheck: {
        host: "string",
        port: 0,
        portName: "string",
        portSpecification: google_native.compute.beta.HTTP2HealthCheckPortSpecification.UseFixedPort,
        proxyHeader: google_native.compute.beta.HTTP2HealthCheckProxyHeader.None,
        requestPath: "string",
        response: "string",
    },
    project: "string",
    httpsHealthCheck: {
        host: "string",
        port: 0,
        portName: "string",
        portSpecification: google_native.compute.beta.HTTPSHealthCheckPortSpecification.UseFixedPort,
        proxyHeader: google_native.compute.beta.HTTPSHealthCheckProxyHeader.None,
        requestPath: "string",
        response: "string",
    },
    kind: "string",
    description: "string",
    healthyThreshold: 0,
    grpcHealthCheck: {
        grpcServiceName: "string",
        port: 0,
        portName: "string",
        portSpecification: google_native.compute.beta.GRPCHealthCheckPortSpecification.UseFixedPort,
    },
    checkIntervalSec: 0,
    requestId: "string",
    sslHealthCheck: {
        port: 0,
        portName: "string",
        portSpecification: google_native.compute.beta.SSLHealthCheckPortSpecification.UseFixedPort,
        proxyHeader: google_native.compute.beta.SSLHealthCheckProxyHeader.None,
        request: "string",
        response: "string",
    },
    tcpHealthCheck: {
        port: 0,
        portName: "string",
        portSpecification: google_native.compute.beta.TCPHealthCheckPortSpecification.UseFixedPort,
        proxyHeader: google_native.compute.beta.TCPHealthCheckProxyHeader.None,
        request: "string",
        response: "string",
    },
    timeoutSec: 0,
    type: google_native.compute.beta.RegionHealthCheckType.Grpc,
    unhealthyThreshold: 0,
});
Copy
type: google-native:compute/beta:RegionHealthCheck
properties:
    checkIntervalSec: 0
    description: string
    grpcHealthCheck:
        grpcServiceName: string
        port: 0
        portName: string
        portSpecification: USE_FIXED_PORT
    healthyThreshold: 0
    http2HealthCheck:
        host: string
        port: 0
        portName: string
        portSpecification: USE_FIXED_PORT
        proxyHeader: NONE
        requestPath: string
        response: string
    httpHealthCheck:
        host: string
        port: 0
        portName: string
        portSpecification: USE_FIXED_PORT
        proxyHeader: NONE
        requestPath: string
        response: string
    httpsHealthCheck:
        host: string
        port: 0
        portName: string
        portSpecification: USE_FIXED_PORT
        proxyHeader: NONE
        requestPath: string
        response: string
    kind: string
    logConfig:
        enable: false
    name: string
    project: string
    region: string
    requestId: string
    sslHealthCheck:
        port: 0
        portName: string
        portSpecification: USE_FIXED_PORT
        proxyHeader: NONE
        request: string
        response: string
    tcpHealthCheck:
        port: 0
        portName: string
        portSpecification: USE_FIXED_PORT
        proxyHeader: NONE
        request: string
        response: string
    timeoutSec: 0
    type: GRPC
    unhealthyThreshold: 0
Copy

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

Region
This property is required.
Changes to this property will trigger replacement.
string
CheckIntervalSec int
How often (in seconds) to send a health check. The default value is 5 seconds.
Description string
An optional description of this resource. Provide this property when you create the resource.
GrpcHealthCheck Pulumi.GoogleNative.Compute.Beta.Inputs.GRPCHealthCheck
HealthyThreshold int
A so-far unhealthy instance will be marked healthy after this many consecutive successes. The default value is 2.
Http2HealthCheck Pulumi.GoogleNative.Compute.Beta.Inputs.HTTP2HealthCheck
HttpHealthCheck Pulumi.GoogleNative.Compute.Beta.Inputs.HTTPHealthCheck
HttpsHealthCheck Pulumi.GoogleNative.Compute.Beta.Inputs.HTTPSHealthCheck
Kind string
Type of the resource.
LogConfig Pulumi.GoogleNative.Compute.Beta.Inputs.HealthCheckLogConfig
Configure logging on this health check.
Name string
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. For example, a name that is 1-63 characters long, matches the regular expression [a-z]([-a-z0-9]*[a-z0-9])?, and otherwise complies with RFC1035. This regular expression describes a name where the first character is a lowercase letter, and all following characters are a dash, lowercase letter, or digit, except the last character, which isn't a dash.
Project Changes to this property will trigger replacement. string
RequestId string
An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported ( 00000000-0000-0000-0000-000000000000).
SslHealthCheck Pulumi.GoogleNative.Compute.Beta.Inputs.SSLHealthCheck
TcpHealthCheck Pulumi.GoogleNative.Compute.Beta.Inputs.TCPHealthCheck
TimeoutSec int
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.
Type Pulumi.GoogleNative.Compute.Beta.RegionHealthCheckType
Specifies the type of the healthCheck, either TCP, SSL, HTTP, HTTPS, HTTP2 or GRPC. Exactly one of the protocol-specific health check fields must be specified, which must match type field.
UnhealthyThreshold int
A so-far healthy instance will be marked unhealthy after this many consecutive failures. The default value is 2.
Region
This property is required.
Changes to this property will trigger replacement.
string
CheckIntervalSec int
How often (in seconds) to send a health check. The default value is 5 seconds.
Description string
An optional description of this resource. Provide this property when you create the resource.
GrpcHealthCheck GRPCHealthCheckArgs
HealthyThreshold int
A so-far unhealthy instance will be marked healthy after this many consecutive successes. The default value is 2.
Http2HealthCheck HTTP2HealthCheckArgs
HttpHealthCheck HTTPHealthCheckTypeArgs
HttpsHealthCheck HTTPSHealthCheckTypeArgs
Kind string
Type of the resource.
LogConfig HealthCheckLogConfigArgs
Configure logging on this health check.
Name string
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. For example, a name that is 1-63 characters long, matches the regular expression [a-z]([-a-z0-9]*[a-z0-9])?, and otherwise complies with RFC1035. This regular expression describes a name where the first character is a lowercase letter, and all following characters are a dash, lowercase letter, or digit, except the last character, which isn't a dash.
Project Changes to this property will trigger replacement. string
RequestId string
An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported ( 00000000-0000-0000-0000-000000000000).
SslHealthCheck SSLHealthCheckArgs
TcpHealthCheck TCPHealthCheckArgs
TimeoutSec int
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.
Type RegionHealthCheckType
Specifies the type of the healthCheck, either TCP, SSL, HTTP, HTTPS, HTTP2 or GRPC. Exactly one of the protocol-specific health check fields must be specified, which must match type field.
UnhealthyThreshold int
A so-far healthy instance will be marked unhealthy after this many consecutive failures. The default value is 2.
region
This property is required.
Changes to this property will trigger replacement.
String
checkIntervalSec Integer
How often (in seconds) to send a health check. The default value is 5 seconds.
description String
An optional description of this resource. Provide this property when you create the resource.
grpcHealthCheck GRPCHealthCheck
healthyThreshold Integer
A so-far unhealthy instance will be marked healthy after this many consecutive successes. The default value is 2.
http2HealthCheck HTTP2HealthCheck
httpHealthCheck HTTPHealthCheck
httpsHealthCheck HTTPSHealthCheck
kind String
Type of the resource.
logConfig HealthCheckLogConfig
Configure logging on this health check.
name String
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. For example, a name that is 1-63 characters long, matches the regular expression [a-z]([-a-z0-9]*[a-z0-9])?, and otherwise complies with RFC1035. This regular expression describes a name where the first character is a lowercase letter, and all following characters are a dash, lowercase letter, or digit, except the last character, which isn't a dash.
project Changes to this property will trigger replacement. String
requestId String
An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported ( 00000000-0000-0000-0000-000000000000).
sslHealthCheck SSLHealthCheck
tcpHealthCheck TCPHealthCheck
timeoutSec Integer
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.
type RegionHealthCheckType
Specifies the type of the healthCheck, either TCP, SSL, HTTP, HTTPS, HTTP2 or GRPC. Exactly one of the protocol-specific health check fields must be specified, which must match type field.
unhealthyThreshold Integer
A so-far healthy instance will be marked unhealthy after this many consecutive failures. The default value is 2.
region
This property is required.
Changes to this property will trigger replacement.
string
checkIntervalSec number
How often (in seconds) to send a health check. The default value is 5 seconds.
description string
An optional description of this resource. Provide this property when you create the resource.
grpcHealthCheck GRPCHealthCheck
healthyThreshold number
A so-far unhealthy instance will be marked healthy after this many consecutive successes. The default value is 2.
http2HealthCheck HTTP2HealthCheck
httpHealthCheck HTTPHealthCheck
httpsHealthCheck HTTPSHealthCheck
kind string
Type of the resource.
logConfig HealthCheckLogConfig
Configure logging on this health check.
name string
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. For example, a name that is 1-63 characters long, matches the regular expression [a-z]([-a-z0-9]*[a-z0-9])?, and otherwise complies with RFC1035. This regular expression describes a name where the first character is a lowercase letter, and all following characters are a dash, lowercase letter, or digit, except the last character, which isn't a dash.
project Changes to this property will trigger replacement. string
requestId string
An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported ( 00000000-0000-0000-0000-000000000000).
sslHealthCheck SSLHealthCheck
tcpHealthCheck TCPHealthCheck
timeoutSec number
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.
type RegionHealthCheckType
Specifies the type of the healthCheck, either TCP, SSL, HTTP, HTTPS, HTTP2 or GRPC. Exactly one of the protocol-specific health check fields must be specified, which must match type field.
unhealthyThreshold number
A so-far healthy instance will be marked unhealthy after this many consecutive failures. The default value is 2.
region
This property is required.
Changes to this property will trigger replacement.
str
check_interval_sec int
How often (in seconds) to send a health check. The default value is 5 seconds.
description str
An optional description of this resource. Provide this property when you create the resource.
grpc_health_check GRPCHealthCheckArgs
healthy_threshold int
A so-far unhealthy instance will be marked healthy after this many consecutive successes. The default value is 2.
http2_health_check HTTP2HealthCheckArgs
http_health_check HTTPHealthCheckArgs
https_health_check HTTPSHealthCheckArgs
kind str
Type of the resource.
log_config HealthCheckLogConfigArgs
Configure logging on this health check.
name str
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. For example, a name that is 1-63 characters long, matches the regular expression [a-z]([-a-z0-9]*[a-z0-9])?, and otherwise complies with RFC1035. This regular expression describes a name where the first character is a lowercase letter, and all following characters are a dash, lowercase letter, or digit, except the last character, which isn't a dash.
project Changes to this property will trigger replacement. str
request_id str
An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported ( 00000000-0000-0000-0000-000000000000).
ssl_health_check SSLHealthCheckArgs
tcp_health_check TCPHealthCheckArgs
timeout_sec int
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.
type RegionHealthCheckType
Specifies the type of the healthCheck, either TCP, SSL, HTTP, HTTPS, HTTP2 or GRPC. Exactly one of the protocol-specific health check fields must be specified, which must match type field.
unhealthy_threshold int
A so-far healthy instance will be marked unhealthy after this many consecutive failures. The default value is 2.
region
This property is required.
Changes to this property will trigger replacement.
String
checkIntervalSec Number
How often (in seconds) to send a health check. The default value is 5 seconds.
description String
An optional description of this resource. Provide this property when you create the resource.
grpcHealthCheck Property Map
healthyThreshold Number
A so-far unhealthy instance will be marked healthy after this many consecutive successes. The default value is 2.
http2HealthCheck Property Map
httpHealthCheck Property Map
httpsHealthCheck Property Map
kind String
Type of the resource.
logConfig Property Map
Configure logging on this health check.
name String
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. For example, a name that is 1-63 characters long, matches the regular expression [a-z]([-a-z0-9]*[a-z0-9])?, and otherwise complies with RFC1035. This regular expression describes a name where the first character is a lowercase letter, and all following characters are a dash, lowercase letter, or digit, except the last character, which isn't a dash.
project Changes to this property will trigger replacement. String
requestId String
An optional request ID to identify requests. Specify a unique request ID so that if you must retry your request, the server will know to ignore the request if it has already been completed. For example, consider a situation where you make an initial request and the request times out. If you make the request again with the same request ID, the server can check if original operation with the same request ID was received, and if so, will ignore the second request. This prevents clients from accidentally creating duplicate commitments. The request ID must be a valid UUID with the exception that zero UUID is not supported ( 00000000-0000-0000-0000-000000000000).
sslHealthCheck Property Map
tcpHealthCheck Property Map
timeoutSec Number
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.
type "GRPC" | "HTTP" | "HTTP2" | "HTTPS" | "INVALID" | "SSL" | "TCP"
Specifies the type of the healthCheck, either TCP, SSL, HTTP, HTTPS, HTTP2 or GRPC. Exactly one of the protocol-specific health check fields must be specified, which must match type field.
unhealthyThreshold Number
A so-far healthy instance will be marked unhealthy after this many consecutive failures. The default value is 2.

Outputs

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

CreationTimestamp string
Creation timestamp in 3339 text format.
Id string
The provider-assigned unique ID for this managed resource.
SelfLink string
Server-defined URL for the resource.
CreationTimestamp string
Creation timestamp in 3339 text format.
Id string
The provider-assigned unique ID for this managed resource.
SelfLink string
Server-defined URL for the resource.
creationTimestamp String
Creation timestamp in 3339 text format.
id String
The provider-assigned unique ID for this managed resource.
selfLink String
Server-defined URL for the resource.
creationTimestamp string
Creation timestamp in 3339 text format.
id string
The provider-assigned unique ID for this managed resource.
selfLink string
Server-defined URL for the resource.
creation_timestamp str
Creation timestamp in 3339 text format.
id str
The provider-assigned unique ID for this managed resource.
self_link str
Server-defined URL for the resource.
creationTimestamp String
Creation timestamp in 3339 text format.
id String
The provider-assigned unique ID for this managed resource.
selfLink String
Server-defined URL for the resource.

Supporting Types

GRPCHealthCheck
, GRPCHealthCheckArgs

GrpcServiceName string
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
Port int
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification Pulumi.GoogleNative.Compute.Beta.GRPCHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
GrpcServiceName string
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
Port int
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification GRPCHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
grpcServiceName String
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
port Integer
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification GRPCHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
grpcServiceName string
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
port number
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
portName string
Not supported.
portSpecification GRPCHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
grpc_service_name str
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
port int
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
port_name str
Not supported.
port_specification GRPCHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
grpcServiceName String
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
port Number
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification "USE_FIXED_PORT" | "USE_NAMED_PORT" | "USE_SERVING_PORT"
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.

GRPCHealthCheckPortSpecification
, GRPCHealthCheckPortSpecificationArgs

UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
GRPCHealthCheckPortSpecificationUseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
GRPCHealthCheckPortSpecificationUseNamedPort
USE_NAMED_PORTNot supported.
GRPCHealthCheckPortSpecificationUseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
USE_FIXED_PORT
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
USE_NAMED_PORT
USE_NAMED_PORTNot supported.
USE_SERVING_PORT
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
"USE_FIXED_PORT"
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
"USE_NAMED_PORT"
USE_NAMED_PORTNot supported.
"USE_SERVING_PORT"
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.

GRPCHealthCheckResponse
, GRPCHealthCheckResponseArgs

GrpcServiceName This property is required. string
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
Port This property is required. int
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
GrpcServiceName This property is required. string
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
Port This property is required. int
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
grpcServiceName This property is required. String
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
port This property is required. Integer
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
grpcServiceName This property is required. string
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
port This property is required. number
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
portName This property is required. string
Not supported.
portSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
grpc_service_name This property is required. str
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
port This property is required. int
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
port_name This property is required. str
Not supported.
port_specification This property is required. str
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
grpcServiceName This property is required. String
The gRPC service name for the health check. This field is optional. The value of grpc_service_name has the following meanings by convention: - Empty service_name means the overall status of all services at the backend. - Non-empty service_name means the health of that gRPC service, as defined by the owner of the service. The grpc_service_name can only be ASCII.
port This property is required. Number
The TCP port number to which the health check prober sends packets. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.

HTTP2HealthCheck
, HTTP2HealthCheckArgs

Host string
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification Pulumi.GoogleNative.Compute.Beta.HTTP2HealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader Pulumi.GoogleNative.Compute.Beta.HTTP2HealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath string
The request path of the HTTP/2 health check request. The default value is /.
Response string
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
Host string
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification HTTP2HealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader HTTP2HealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath string
The request path of the HTTP/2 health check request. The default value is /.
Response string
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host String
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port Integer
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification HTTP2HealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader HTTP2HealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath String
The request path of the HTTP/2 health check request. The default value is /.
response String
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host string
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName string
Not supported.
portSpecification HTTP2HealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader HTTP2HealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath string
The request path of the HTTP/2 health check request. The default value is /.
response string
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host str
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
port_name str
Not supported.
port_specification HTTP2HealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header HTTP2HealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request_path str
The request path of the HTTP/2 health check request. The default value is /.
response str
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host String
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port Number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification "USE_FIXED_PORT" | "USE_NAMED_PORT" | "USE_SERVING_PORT"
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader "NONE" | "PROXY_V1"
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath String
The request path of the HTTP/2 health check request. The default value is /.
response String
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http

HTTP2HealthCheckPortSpecification
, HTTP2HealthCheckPortSpecificationArgs

UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
HTTP2HealthCheckPortSpecificationUseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
HTTP2HealthCheckPortSpecificationUseNamedPort
USE_NAMED_PORTNot supported.
HTTP2HealthCheckPortSpecificationUseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
USE_FIXED_PORT
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
USE_NAMED_PORT
USE_NAMED_PORTNot supported.
USE_SERVING_PORT
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
"USE_FIXED_PORT"
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
"USE_NAMED_PORT"
USE_NAMED_PORTNot supported.
"USE_SERVING_PORT"
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.

HTTP2HealthCheckProxyHeader
, HTTP2HealthCheckProxyHeaderArgs

None
NONE
ProxyV1
PROXY_V1
HTTP2HealthCheckProxyHeaderNone
NONE
HTTP2HealthCheckProxyHeaderProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
NONE
NONE
PROXY_V1
PROXY_V1
"NONE"
NONE
"PROXY_V1"
PROXY_V1

HTTP2HealthCheckResponse
, HTTP2HealthCheckResponseArgs

Host This property is required. string
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath This property is required. string
The request path of the HTTP/2 health check request. The default value is /.
Response This property is required. string
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
Host This property is required. string
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath This property is required. string
The request path of the HTTP/2 health check request. The default value is /.
Response This property is required. string
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. String
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. Integer
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. String
The request path of the HTTP/2 health check request. The default value is /.
response This property is required. String
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. string
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. string
Not supported.
portSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. string
The request path of the HTTP/2 health check request. The default value is /.
response This property is required. string
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. str
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
port_name This property is required. str
Not supported.
port_specification This property is required. str
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header This property is required. str
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request_path This property is required. str
The request path of the HTTP/2 health check request. The default value is /.
response This property is required. str
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. String
The value of the host header in the HTTP/2 health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. Number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. String
The request path of the HTTP/2 health check request. The default value is /.
response This property is required. String
Creates a content-based HTTP/2 health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http

HTTPHealthCheck
, HTTPHealthCheckArgs

Host string
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification Pulumi.GoogleNative.Compute.Beta.HTTPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader Pulumi.GoogleNative.Compute.Beta.HTTPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath string
The request path of the HTTP health check request. The default value is /.
Response string
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
Host string
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification HTTPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader HTTPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath string
The request path of the HTTP health check request. The default value is /.
Response string
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host String
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port Integer
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification HTTPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader HTTPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath String
The request path of the HTTP health check request. The default value is /.
response String
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host string
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port number
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName string
Not supported.
portSpecification HTTPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader HTTPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath string
The request path of the HTTP health check request. The default value is /.
response string
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host str
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
port_name str
Not supported.
port_specification HTTPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header HTTPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request_path str
The request path of the HTTP health check request. The default value is /.
response str
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host String
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port Number
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification "USE_FIXED_PORT" | "USE_NAMED_PORT" | "USE_SERVING_PORT"
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader "NONE" | "PROXY_V1"
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath String
The request path of the HTTP health check request. The default value is /.
response String
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http

HTTPHealthCheckPortSpecification
, HTTPHealthCheckPortSpecificationArgs

UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
HTTPHealthCheckPortSpecificationUseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
HTTPHealthCheckPortSpecificationUseNamedPort
USE_NAMED_PORTNot supported.
HTTPHealthCheckPortSpecificationUseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
USE_FIXED_PORT
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
USE_NAMED_PORT
USE_NAMED_PORTNot supported.
USE_SERVING_PORT
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
"USE_FIXED_PORT"
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
"USE_NAMED_PORT"
USE_NAMED_PORTNot supported.
"USE_SERVING_PORT"
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.

HTTPHealthCheckProxyHeader
, HTTPHealthCheckProxyHeaderArgs

None
NONE
ProxyV1
PROXY_V1
HTTPHealthCheckProxyHeaderNone
NONE
HTTPHealthCheckProxyHeaderProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
NONE
NONE
PROXY_V1
PROXY_V1
"NONE"
NONE
"PROXY_V1"
PROXY_V1

HTTPHealthCheckResponse
, HTTPHealthCheckResponseArgs

Host This property is required. string
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath This property is required. string
The request path of the HTTP health check request. The default value is /.
Response This property is required. string
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
Host This property is required. string
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath This property is required. string
The request path of the HTTP health check request. The default value is /.
Response This property is required. string
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. String
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. Integer
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. String
The request path of the HTTP health check request. The default value is /.
response This property is required. String
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. string
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. number
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName This property is required. string
Not supported.
portSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. string
The request path of the HTTP health check request. The default value is /.
response This property is required. string
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. str
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
port_name This property is required. str
Not supported.
port_specification This property is required. str
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header This property is required. str
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request_path This property is required. str
The request path of the HTTP health check request. The default value is /.
response This property is required. str
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. String
The value of the host header in the HTTP health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. Number
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Also supported in legacy HTTP health checks for target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. String
The request path of the HTTP health check request. The default value is /.
response This property is required. String
Creates a content-based HTTP health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http

HTTPSHealthCheck
, HTTPSHealthCheckArgs

Host string
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification Pulumi.GoogleNative.Compute.Beta.HTTPSHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader Pulumi.GoogleNative.Compute.Beta.HTTPSHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath string
The request path of the HTTPS health check request. The default value is /.
Response string
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
Host string
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification HTTPSHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader HTTPSHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath string
The request path of the HTTPS health check request. The default value is /.
Response string
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host String
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port Integer
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification HTTPSHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader HTTPSHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath String
The request path of the HTTPS health check request. The default value is /.
response String
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host string
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName string
Not supported.
portSpecification HTTPSHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader HTTPSHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath string
The request path of the HTTPS health check request. The default value is /.
response string
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host str
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
port_name str
Not supported.
port_specification HTTPSHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header HTTPSHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request_path str
The request path of the HTTPS health check request. The default value is /.
response str
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host String
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port Number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification "USE_FIXED_PORT" | "USE_NAMED_PORT" | "USE_SERVING_PORT"
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader "NONE" | "PROXY_V1"
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath String
The request path of the HTTPS health check request. The default value is /.
response String
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http

HTTPSHealthCheckPortSpecification
, HTTPSHealthCheckPortSpecificationArgs

UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
HTTPSHealthCheckPortSpecificationUseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
HTTPSHealthCheckPortSpecificationUseNamedPort
USE_NAMED_PORTNot supported.
HTTPSHealthCheckPortSpecificationUseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
USE_FIXED_PORT
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
USE_NAMED_PORT
USE_NAMED_PORTNot supported.
USE_SERVING_PORT
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
"USE_FIXED_PORT"
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
"USE_NAMED_PORT"
USE_NAMED_PORTNot supported.
"USE_SERVING_PORT"
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.

HTTPSHealthCheckProxyHeader
, HTTPSHealthCheckProxyHeaderArgs

None
NONE
ProxyV1
PROXY_V1
HTTPSHealthCheckProxyHeaderNone
NONE
HTTPSHealthCheckProxyHeaderProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
NONE
NONE
PROXY_V1
PROXY_V1
"NONE"
NONE
"PROXY_V1"
PROXY_V1

HTTPSHealthCheckResponse
, HTTPSHealthCheckResponseArgs

Host This property is required. string
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath This property is required. string
The request path of the HTTPS health check request. The default value is /.
Response This property is required. string
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
Host This property is required. string
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
RequestPath This property is required. string
The request path of the HTTPS health check request. The default value is /.
Response This property is required. string
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. String
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. Integer
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. String
The request path of the HTTPS health check request. The default value is /.
response This property is required. String
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. string
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. string
Not supported.
portSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. string
The request path of the HTTPS health check request. The default value is /.
response This property is required. string
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. str
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
port_name This property is required. str
Not supported.
port_specification This property is required. str
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header This property is required. str
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request_path This property is required. str
The request path of the HTTPS health check request. The default value is /.
response This property is required. str
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http
host This property is required. String
The value of the host header in the HTTPS health check request. If left empty (default value), the host header is set to the destination IP address to which health check packets are sent. The destination IP address depends on the type of load balancer. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#hc-packet-dest
port This property is required. Number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
requestPath This property is required. String
The request path of the HTTPS health check request. The default value is /.
response This property is required. String
Creates a content-based HTTPS health check. In addition to the required HTTP 200 (OK) status code, you can configure the health check to pass only when the backend sends this specific ASCII response string within the first 1024 bytes of the HTTP response body. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-http

HealthCheckLogConfig
, HealthCheckLogConfigArgs

Enable bool
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
Enable bool
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
enable Boolean
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
enable boolean
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
enable bool
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
enable Boolean
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.

HealthCheckLogConfigResponse
, HealthCheckLogConfigResponseArgs

Enable This property is required. bool
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
Enable This property is required. bool
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
enable This property is required. Boolean
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
enable This property is required. boolean
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
enable This property is required. bool
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.
enable This property is required. Boolean
Indicates whether or not to export logs. This is false by default, which means no health check logging will be done.

RegionHealthCheckType
, RegionHealthCheckTypeArgs

Grpc
GRPC
Http
HTTP
Http2
HTTP2
Https
HTTPS
Invalid
INVALID
Ssl
SSL
Tcp
TCP
RegionHealthCheckTypeGrpc
GRPC
RegionHealthCheckTypeHttp
HTTP
RegionHealthCheckTypeHttp2
HTTP2
RegionHealthCheckTypeHttps
HTTPS
RegionHealthCheckTypeInvalid
INVALID
RegionHealthCheckTypeSsl
SSL
RegionHealthCheckTypeTcp
TCP
Grpc
GRPC
Http
HTTP
Http2
HTTP2
Https
HTTPS
Invalid
INVALID
Ssl
SSL
Tcp
TCP
Grpc
GRPC
Http
HTTP
Http2
HTTP2
Https
HTTPS
Invalid
INVALID
Ssl
SSL
Tcp
TCP
GRPC
GRPC
HTTP
HTTP
HTTP2
HTTP2
HTTPS
HTTPS
INVALID
INVALID
SSL
SSL
TCP
TCP
"GRPC"
GRPC
"HTTP"
HTTP
"HTTP2"
HTTP2
"HTTPS"
HTTPS
"INVALID"
INVALID
"SSL"
SSL
"TCP"
TCP

SSLHealthCheck
, SSLHealthCheckArgs

Port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification Pulumi.GoogleNative.Compute.Beta.SSLHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader Pulumi.GoogleNative.Compute.Beta.SSLHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
Request string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
Response string
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
Port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification SSLHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader SSLHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
Request string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
Response string
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port Integer
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification SSLHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader SSLHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request String
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
response String
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName string
Not supported.
portSpecification SSLHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader SSLHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
response string
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
port_name str
Not supported.
port_specification SSLHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header SSLHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request str
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
response str
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port Number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification "USE_FIXED_PORT" | "USE_NAMED_PORT" | "USE_SERVING_PORT"
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader "NONE" | "PROXY_V1"
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request String
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
response String
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp

SSLHealthCheckPortSpecification
, SSLHealthCheckPortSpecificationArgs

UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
SSLHealthCheckPortSpecificationUseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
SSLHealthCheckPortSpecificationUseNamedPort
USE_NAMED_PORTNot supported.
SSLHealthCheckPortSpecificationUseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
USE_FIXED_PORT
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
USE_NAMED_PORT
USE_NAMED_PORTNot supported.
USE_SERVING_PORT
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
"USE_FIXED_PORT"
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
"USE_NAMED_PORT"
USE_NAMED_PORTNot supported.
"USE_SERVING_PORT"
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.

SSLHealthCheckProxyHeader
, SSLHealthCheckProxyHeaderArgs

None
NONE
ProxyV1
PROXY_V1
SSLHealthCheckProxyHeaderNone
NONE
SSLHealthCheckProxyHeaderProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
NONE
NONE
PROXY_V1
PROXY_V1
"NONE"
NONE
"PROXY_V1"
PROXY_V1

SSLHealthCheckResponse
, SSLHealthCheckResponseArgs

Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
Request This property is required. string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
Response This property is required. string
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
Request This property is required. string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
Response This property is required. string
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port This property is required. Integer
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request This property is required. String
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
response This property is required. String
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port This property is required. number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. string
Not supported.
portSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request This property is required. string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
response This property is required. string
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
port_name This property is required. str
Not supported.
port_specification This property is required. str
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header This property is required. str
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request This property is required. str
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
response This property is required. str
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port This property is required. Number
The TCP port number to which the health check prober sends packets. The default value is 443. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request This property is required. String
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection and SSL handshake.
response This property is required. String
Creates a content-based SSL health check. In addition to establishing a TCP connection and the TLS handshake, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp

TCPHealthCheck
, TCPHealthCheckArgs

Port int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification Pulumi.GoogleNative.Compute.Beta.TCPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader Pulumi.GoogleNative.Compute.Beta.TCPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
Request string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
Response string
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
Port int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
PortName string
Not supported.
PortSpecification TCPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader TCPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
Request string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
Response string
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port Integer
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification TCPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader TCPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request String
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
response String
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port number
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName string
Not supported.
portSpecification TCPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader TCPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
response string
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
port_name str
Not supported.
port_specification TCPHealthCheckPortSpecification
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header TCPHealthCheckProxyHeader
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request str
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
response str
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port Number
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName String
Not supported.
portSpecification "USE_FIXED_PORT" | "USE_NAMED_PORT" | "USE_SERVING_PORT"
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader "NONE" | "PROXY_V1"
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request String
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
response String
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp

TCPHealthCheckPortSpecification
, TCPHealthCheckPortSpecificationArgs

UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
TCPHealthCheckPortSpecificationUseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
TCPHealthCheckPortSpecificationUseNamedPort
USE_NAMED_PORTNot supported.
TCPHealthCheckPortSpecificationUseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
UseFixedPort
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
UseNamedPort
USE_NAMED_PORTNot supported.
UseServingPort
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
USE_FIXED_PORT
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
USE_NAMED_PORT
USE_NAMED_PORTNot supported.
USE_SERVING_PORT
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.
"USE_FIXED_PORT"
USE_FIXED_PORTThe port number in the health check's port is used for health checking. Applies to network endpoint group and instance group backends.
"USE_NAMED_PORT"
USE_NAMED_PORTNot supported.
"USE_SERVING_PORT"
USE_SERVING_PORTFor network endpoint group backends, the health check uses the port number specified on each endpoint in the network endpoint group. For instance group backends, the health check uses the port number specified for the backend service's named port defined in the instance group's named ports.

TCPHealthCheckProxyHeader
, TCPHealthCheckProxyHeaderArgs

None
NONE
ProxyV1
PROXY_V1
TCPHealthCheckProxyHeaderNone
NONE
TCPHealthCheckProxyHeaderProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
None
NONE
ProxyV1
PROXY_V1
NONE
NONE
PROXY_V1
PROXY_V1
"NONE"
NONE
"PROXY_V1"
PROXY_V1

TCPHealthCheckResponse
, TCPHealthCheckResponseArgs

Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
Request This property is required. string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
Response This property is required. string
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
Port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
PortName This property is required. string
Not supported.
PortSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
ProxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
Request This property is required. string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
Response This property is required. string
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port This property is required. Integer
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request This property is required. String
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
response This property is required. String
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port This property is required. number
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName This property is required. string
Not supported.
portSpecification This property is required. string
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. string
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request This property is required. string
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
response This property is required. string
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port This property is required. int
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
port_name This property is required. str
Not supported.
port_specification This property is required. str
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxy_header This property is required. str
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request This property is required. str
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
response This property is required. str
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp
port This property is required. Number
The TCP port number to which the health check prober sends packets. The default value is 80. Valid values are 1 through 65535.
portName This property is required. String
Not supported.
portSpecification This property is required. String
Specifies how a port is selected for health checking. Can be one of the following values: USE_FIXED_PORT: Specifies a port number explicitly using the port field in the health check. Supported by backend services for pass-through load balancers and backend services for proxy load balancers. Not supported by target pools. The health check supports all backends supported by the backend service provided the backend can be health checked. For example, GCE_VM_IP network endpoint groups, GCE_VM_IP_PORT network endpoint groups, and instance group backends. USE_NAMED_PORT: Not supported. USE_SERVING_PORT: Provides an indirect method of specifying the health check port by referring to the backend service. Only supported by backend services for proxy load balancers. Not supported by target pools. Not supported by backend services for pass-through load balancers. Supports all backends that can be health checked; for example, GCE_VM_IP_PORT network endpoint groups and instance group backends. For GCE_VM_IP_PORT network endpoint group backends, the health check uses the port number specified for each endpoint in the network endpoint group. For instance group backends, the health check uses the port number determined by looking up the backend service's named port in the instance group's list of named ports.
proxyHeader This property is required. String
Specifies the type of proxy header to append before sending data to the backend, either NONE or PROXY_V1. The default is NONE.
request This property is required. String
Instructs the health check prober to send this exact ASCII string, up to 1024 bytes in length, after establishing the TCP connection.
response This property is required. String
Creates a content-based TCP health check. In addition to establishing a TCP connection, you can configure the health check to pass only when the backend sends this exact response ASCII string, up to 1024 bytes in length. For details, see: https://cloud.google.com/load-balancing/docs/health-check-concepts#criteria-protocol-ssl-tcp

Package Details

Repository
Google Cloud Native pulumi/pulumi-google-native
License
Apache-2.0

Google Cloud Native is in preview. Google Cloud Classic is fully supported.

Google Cloud Native v0.32.0 published on Wednesday, Nov 29, 2023 by Pulumi
pulumi/pulumi-google-native