Docs Packages
  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-native logo

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 string
    The unique name of the resource.
    args RegionHealthCheckArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args 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 string
    The unique name of the resource.
    args RegionHealthCheckArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RegionHealthCheckArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args 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,
});

    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),
})

    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());

    google_native_region_health_check_resource = google_native.compute.beta.RegionHealthCheck("google-nativeRegionHealthCheckResource",
    region="string",
    log_config=google_native.compute.beta.HealthCheckLogConfigArgs(
        enable=False,
    ),
    http_health_check=google_native.compute.beta.HTTPHealthCheckArgs(
        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=google_native.compute.beta.HTTP2HealthCheckArgs(
        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=google_native.compute.beta.HTTPSHealthCheckArgs(
        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=google_native.compute.beta.GRPCHealthCheckArgs(
        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=google_native.compute.beta.SSLHealthCheckArgs(
        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=google_native.compute.beta.TCPHealthCheckArgs(
        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)

    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,
});

    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

    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

    The RegionHealthCheck resource accepts the following input properties:

    Region 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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

    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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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

    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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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

    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 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.

    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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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

    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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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

    Package Details

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

    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