RegionCompositeHealthCheck class

A composite health check resource specifies the health source resources and the health destination resource to which the aggregated health result from the health source resources is delivered.

To get more information about RegionCompositeHealthCheck, see:

Example Usage

Compute Region Composite Health Check Basic

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

const hap = new gcp.compute.RegionHealthAggregationPolicy("hap", {
    name: "test-composite-health-check-hap",
    description: "health aggregation policy for health source",
    region: "us-central1",
});
const defaultHealthCheck = new gcp.compute.HealthCheck("default", {
    name: "test-composite-health-check-hc",
    httpHealthCheck: {
        port: 80,
    },
});
const defaultRegionBackendService = new gcp.compute.RegionBackendService("default", {
    name: "test-composite-health-check-bs",
    region: "us-central1",
    healthChecks: defaultHealthCheck.id,
    loadBalancingScheme: "INTERNAL",
});
const _default = new gcp.compute.RegionHealthSource("default", {
    name: "test-composite-health-check-hs",
    region: "us-central1",
    sourceType: "BACKEND_SERVICE",
    sources: defaultRegionBackendService.id,
    healthAggregationPolicy: hap.id,
});
const defaultNetwork = new gcp.compute.Network("default", {
    name: "test-composite-health-check-net",
    autoCreateSubnetworks: false,
});
const defaultSubnetwork = new gcp.compute.Subnetwork("default", {
    name: "test-composite-health-check-sub",
    ipCidrRange: "10.2.0.0/16",
    region: "us-central1",
    network: defaultNetwork.id,
});
const defaultForwardingRule = new gcp.compute.ForwardingRule("default", {
    name: "test-composite-health-check-fr",
    region: "us-central1",
    loadBalancingScheme: "INTERNAL",
    backendService: defaultRegionBackendService.id,
    network: defaultNetwork.id,
    subnetwork: defaultSubnetwork.id,
    ipProtocol: "TCP",
    allPorts: true,
});
const exampleTestCompositeHealthCheck = new gcp.compute.RegionCompositeHealthCheck("example_test_composite_health_check", {
    name: "test-composite-health-check",
    description: "test regional composite health check resource",
    region: "us-central1",
    healthSources: [_default.id],
    healthDestination: defaultForwardingRule.id,
});

import pulumi
import pulumi_gcp as gcp

hap = gcp.compute.RegionHealthAggregationPolicy("hap",
    name="test-composite-health-check-hap",
    description="health aggregation policy for health source",
    region="us-central1")
default_health_check = gcp.compute.HealthCheck("default",
    name="test-composite-health-check-hc",
    http_health_check={
        "port": 80,
    })
default_region_backend_service = gcp.compute.RegionBackendService("default",
    name="test-composite-health-check-bs",
    region="us-central1",
    health_checks=default_health_check.id,
    load_balancing_scheme="INTERNAL")
default = gcp.compute.RegionHealthSource("default",
    name="test-composite-health-check-hs",
    region="us-central1",
    source_type="BACKEND_SERVICE",
    sources=default_region_backend_service.id,
    health_aggregation_policy=hap.id)
default_network = gcp.compute.Network("default",
    name="test-composite-health-check-net",
    auto_create_subnetworks=False)
default_subnetwork = gcp.compute.Subnetwork("default",
    name="test-composite-health-check-sub",
    ip_cidr_range="10.2.0.0/16",
    region="us-central1",
    network=default_network.id)
default_forwarding_rule = gcp.compute.ForwardingRule("default",
    name="test-composite-health-check-fr",
    region="us-central1",
    load_balancing_scheme="INTERNAL",
    backend_service=default_region_backend_service.id,
    network=default_network.id,
    subnetwork=default_subnetwork.id,
    ip_protocol="TCP",
    all_ports=True)
example_test_composite_health_check = gcp.compute.RegionCompositeHealthCheck("example_test_composite_health_check",
    name="test-composite-health-check",
    description="test regional composite health check resource",
    region="us-central1",
    health_sources=[default.id],
    health_destination=default_forwarding_rule.id)

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

return await Deployment.RunAsync(() =>
{
    var hap = new Gcp.Compute.RegionHealthAggregationPolicy("hap", new()
    {
        Name = "test-composite-health-check-hap",
        Description = "health aggregation policy for health source",
        Region = "us-central1",
    });

    var defaultHealthCheck = new Gcp.Compute.HealthCheck("default", new()
    {
        Name = "test-composite-health-check-hc",
        HttpHealthCheck = new Gcp.Compute.Inputs.HealthCheckHttpHealthCheckArgs
        {
            Port = 80,
        },
    });

    var defaultRegionBackendService = new Gcp.Compute.RegionBackendService("default", new()
    {
        Name = "test-composite-health-check-bs",
        Region = "us-central1",
        HealthChecks = defaultHealthCheck.Id,
        LoadBalancingScheme = "INTERNAL",
    });

    var @default = new Gcp.Compute.RegionHealthSource("default", new()
    {
        Name = "test-composite-health-check-hs",
        Region = "us-central1",
        SourceType = "BACKEND_SERVICE",
        Sources = defaultRegionBackendService.Id,
        HealthAggregationPolicy = hap.Id,
    });

    var defaultNetwork = new Gcp.Compute.Network("default", new()
    {
        Name = "test-composite-health-check-net",
        AutoCreateSubnetworks = false,
    });

    var defaultSubnetwork = new Gcp.Compute.Subnetwork("default", new()
    {
        Name = "test-composite-health-check-sub",
        IpCidrRange = "10.2.0.0/16",
        Region = "us-central1",
        Network = defaultNetwork.Id,
    });

    var defaultForwardingRule = new Gcp.Compute.ForwardingRule("default", new()
    {
        Name = "test-composite-health-check-fr",
        Region = "us-central1",
        LoadBalancingScheme = "INTERNAL",
        BackendService = defaultRegionBackendService.Id,
        Network = defaultNetwork.Id,
        Subnetwork = defaultSubnetwork.Id,
        IpProtocol = "TCP",
        AllPorts = true,
    });

    var exampleTestCompositeHealthCheck = new Gcp.Compute.RegionCompositeHealthCheck("example_test_composite_health_check", new()
    {
        Name = "test-composite-health-check",
        Description = "test regional composite health check resource",
        Region = "us-central1",
        HealthSources = new[]
        {
            @default.Id,
        },
        HealthDestination = defaultForwardingRule.Id,
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		hap, err := compute.NewRegionHealthAggregationPolicy(ctx, "hap", &compute.RegionHealthAggregationPolicyArgs{
			Name:        pulumi.String("test-composite-health-check-hap"),
			Description: pulumi.String("health aggregation policy for health source"),
			Region:      pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		defaultHealthCheck, err := compute.NewHealthCheck(ctx, "default", &compute.HealthCheckArgs{
			Name: pulumi.String("test-composite-health-check-hc"),
			HttpHealthCheck: &compute.HealthCheckHttpHealthCheckArgs{
				Port: pulumi.Int(80),
			},
		})
		if err != nil {
			return err
		}
		defaultRegionBackendService, err := compute.NewRegionBackendService(ctx, "default", &compute.RegionBackendServiceArgs{
			Name:                pulumi.String("test-composite-health-check-bs"),
			Region:              pulumi.String("us-central1"),
			HealthChecks:        defaultHealthCheck.ID().ToIDOutput().ToStringOutput(),
			LoadBalancingScheme: pulumi.String("INTERNAL"),
		})
		if err != nil {
			return err
		}
		_default, err := compute.NewRegionHealthSource(ctx, "default", &compute.RegionHealthSourceArgs{
			Name:                    pulumi.String("test-composite-health-check-hs"),
			Region:                  pulumi.String("us-central1"),
			SourceType:              pulumi.String("BACKEND_SERVICE"),
			Sources:                 defaultRegionBackendService.ID().ToIDOutput().ToStringOutput(),
			HealthAggregationPolicy: hap.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		defaultNetwork, err := compute.NewNetwork(ctx, "default", &compute.NetworkArgs{
			Name:                  pulumi.String("test-composite-health-check-net"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		defaultSubnetwork, err := compute.NewSubnetwork(ctx, "default", &compute.SubnetworkArgs{
			Name:        pulumi.String("test-composite-health-check-sub"),
			IpCidrRange: pulumi.String("10.2.0.0/16"),
			Region:      pulumi.String("us-central1"),
			Network:     defaultNetwork.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		defaultForwardingRule, err := compute.NewForwardingRule(ctx, "default", &compute.ForwardingRuleArgs{
			Name:                pulumi.String("test-composite-health-check-fr"),
			Region:              pulumi.String("us-central1"),
			LoadBalancingScheme: pulumi.String("INTERNAL"),
			BackendService:      defaultRegionBackendService.ID().ToIDOutput().ToStringOutput(),
			Network:             defaultNetwork.ID().ToIDOutput().ToStringOutput(),
			Subnetwork:          defaultSubnetwork.ID().ToIDOutput().ToStringOutput(),
			IpProtocol:          pulumi.String("TCP"),
			AllPorts:            pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewRegionCompositeHealthCheck(ctx, "example_test_composite_health_check", &compute.RegionCompositeHealthCheckArgs{
			Name:        pulumi.String("test-composite-health-check"),
			Description: pulumi.String("test regional composite health check resource"),
			Region:      pulumi.String("us-central1"),
			HealthSources: pulumi.StringArray{
				_default.ID().ToIDOutput().ToStringOutput(),
			},
			HealthDestination: defaultForwardingRule.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
  }
}

resource "gcp_compute_regioncompositehealthcheck" "example_test_composite_health_check" {
  name               = "test-composite-health-check"
  description        = "test regional composite health check resource"
  region             = "us-central1"
  health_sources     = [gcp_compute_regionhealthsource.default.id]
  health_destination = gcp_compute_forwardingrule.default.id
}
resource "gcp_compute_regionhealthsource" "default" {
  name                      = "test-composite-health-check-hs"
  region                    = "us-central1"
  source_type               = "BACKEND_SERVICE"
  sources                   = gcp_compute_regionbackendservice.default.id
  health_aggregation_policy = gcp_compute_regionhealthaggregationpolicy.hap.id
}
resource "gcp_compute_regionhealthaggregationpolicy" "hap" {
  name        = "test-composite-health-check-hap"
  description = "health aggregation policy for health source"
  region      = "us-central1"
}
resource "gcp_compute_healthcheck" "default" {
  name = "test-composite-health-check-hc"
  http_health_check = {
    port = 80
  }
}
resource "gcp_compute_regionbackendservice" "default" {
  name                  = "test-composite-health-check-bs"
  region                = "us-central1"
  health_checks         = gcp_compute_healthcheck.default.id
  load_balancing_scheme = "INTERNAL"
}
resource "gcp_compute_forwardingrule" "default" {
  name                  = "test-composite-health-check-fr"
  region                = "us-central1"
  load_balancing_scheme = "INTERNAL"
  backend_service       = gcp_compute_regionbackendservice.default.id
  network               = gcp_compute_network.default.id
  subnetwork            = gcp_compute_subnetwork.default.id
  ip_protocol           = "TCP"
  all_ports             = true
}
resource "gcp_compute_network" "default" {
  name                    = "test-composite-health-check-net"
  auto_create_subnetworks = false
}
resource "gcp_compute_subnetwork" "default" {
  name          = "test-composite-health-check-sub"
  ip_cidr_range = "10.2.0.0/16"
  region        = "us-central1"
  network       = gcp_compute_network.default.id
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthAggregationPolicy;
import com.pulumi.gcp.compute.RegionHealthAggregationPolicyArgs;
import com.pulumi.gcp.compute.HealthCheck;
import com.pulumi.gcp.compute.HealthCheckArgs;
import com.pulumi.gcp.compute.inputs.HealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.gcp.compute.RegionHealthSource;
import com.pulumi.gcp.compute.RegionHealthSourceArgs;
import com.pulumi.gcp.compute.Network;
import com.pulumi.gcp.compute.NetworkArgs;
import com.pulumi.gcp.compute.Subnetwork;
import com.pulumi.gcp.compute.SubnetworkArgs;
import com.pulumi.gcp.compute.ForwardingRule;
import com.pulumi.gcp.compute.ForwardingRuleArgs;
import com.pulumi.gcp.compute.RegionCompositeHealthCheck;
import com.pulumi.gcp.compute.RegionCompositeHealthCheckArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var hap = new RegionHealthAggregationPolicy("hap", RegionHealthAggregationPolicyArgs.builder()
            .name("test-composite-health-check-hap")
            .description("health aggregation policy for health source")
            .region("us-central1")
            .build());

        var defaultHealthCheck = new HealthCheck("defaultHealthCheck", HealthCheckArgs.builder()
            .name("test-composite-health-check-hc")
            .httpHealthCheck(HealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());

        var defaultRegionBackendService = new RegionBackendService("defaultRegionBackendService", RegionBackendServiceArgs.builder()
            .name("test-composite-health-check-bs")
            .region("us-central1")
            .healthChecks(defaultHealthCheck.id())
            .loadBalancingScheme("INTERNAL")
            .build());

        var default_ = new RegionHealthSource("default", RegionHealthSourceArgs.builder()
            .name("test-composite-health-check-hs")
            .region("us-central1")
            .sourceType("BACKEND_SERVICE")
            .sources(defaultRegionBackendService.id())
            .healthAggregationPolicy(hap.id())
            .build());

        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()
            .name("test-composite-health-check-net")
            .autoCreateSubnetworks(false)
            .build());

        var defaultSubnetwork = new Subnetwork("defaultSubnetwork", SubnetworkArgs.builder()
            .name("test-composite-health-check-sub")
            .ipCidrRange("10.2.0.0/16")
            .region("us-central1")
            .network(defaultNetwork.id())
            .build());

        var defaultForwardingRule = new ForwardingRule("defaultForwardingRule", ForwardingRuleArgs.builder()
            .name("test-composite-health-check-fr")
            .region("us-central1")
            .loadBalancingScheme("INTERNAL")
            .backendService(defaultRegionBackendService.id())
            .network(defaultNetwork.id())
            .subnetwork(defaultSubnetwork.id())
            .ipProtocol("TCP")
            .allPorts(true)
            .build());

        var exampleTestCompositeHealthCheck = new RegionCompositeHealthCheck("exampleTestCompositeHealthCheck", RegionCompositeHealthCheckArgs.builder()
            .name("test-composite-health-check")
            .description("test regional composite health check resource")
            .region("us-central1")
            .healthSources(default_.id())
            .healthDestination(defaultForwardingRule.id())
            .build());

    }
}

resources:
  exampleTestCompositeHealthCheck:
    type: gcp:compute:RegionCompositeHealthCheck
    name: example_test_composite_health_check
    properties:
      name: test-composite-health-check
      description: test regional composite health check resource
      region: us-central1
      healthSources:
        - ${default.id}
      healthDestination: ${defaultForwardingRule.id}
  default:
    type: gcp:compute:RegionHealthSource
    properties:
      name: test-composite-health-check-hs
      region: us-central1
      sourceType: BACKEND_SERVICE
      sources: ${defaultRegionBackendService.id}
      healthAggregationPolicy: ${hap.id}
  hap:
    type: gcp:compute:RegionHealthAggregationPolicy
    properties:
      name: test-composite-health-check-hap
      description: health aggregation policy for health source
      region: us-central1
  defaultHealthCheck:
    type: gcp:compute:HealthCheck
    name: default
    properties:
      name: test-composite-health-check-hc
      httpHealthCheck:
        port: 80
  defaultRegionBackendService:
    type: gcp:compute:RegionBackendService
    name: default
    properties:
      name: test-composite-health-check-bs
      region: us-central1
      healthChecks: ${defaultHealthCheck.id}
      loadBalancingScheme: INTERNAL
  defaultForwardingRule:
    type: gcp:compute:ForwardingRule
    name: default
    properties:
      name: test-composite-health-check-fr
      region: us-central1
      loadBalancingScheme: INTERNAL
      backendService: ${defaultRegionBackendService.id}
      network: ${defaultNetwork.id}
      subnetwork: ${defaultSubnetwork.id}
      ipProtocol: TCP
      allPorts: true
  defaultNetwork:
    type: gcp:compute:Network
    name: default
    properties:
      name: test-composite-health-check-net
      autoCreateSubnetworks: false
  defaultSubnetwork:
    type: gcp:compute:Subnetwork
    name: default
    properties:
      name: test-composite-health-check-sub
      ipCidrRange: 10.2.0.0/16
      region: us-central1
      network: ${defaultNetwork.id}

Import

RegionCompositeHealthCheck can be imported using any of these accepted formats:

projects/{{project}}/regions/{{region}}/compositeHealthChecks/{{name}}
{{project}}/{{region}}/{{name}}
{{region}}/{{name}}
{{name}}

When using the pulumi import command, RegionCompositeHealthCheck can be imported using one of the formats above. For example:

$ pulumi import gcp:compute/regionCompositeHealthCheck:RegionCompositeHealthCheck default projects/{{project}}/regions/{{region}}/compositeHealthChecks/{{name}}
$ pulumi import gcp:compute/regionCompositeHealthCheck:RegionCompositeHealthCheck default {{project}}/{{region}}/{{name}}
$ pulumi import gcp:compute/regionCompositeHealthCheck:RegionCompositeHealthCheck default {{region}}/{{name}}
$ pulumi import gcp:compute/regionCompositeHealthCheck:RegionCompositeHealthCheck default {{name}}

Constructors

RegionCompositeHealthCheck(String name, {RegionCompositeHealthCheckArgs? args, CustomResourceOptions? options}): Creates a new RegionCompositeHealthCheck. name The Pulumi resource name. args Arguments used to configure this RegionCompositeHealthCheck. The set of arguments for RegionCompositeHealthCheck. options Resource options controlling this resource's behavior.
RegionCompositeHealthCheck.reference(String urn): Creates a typed reference to an existing RegionCompositeHealthCheck resource.

Properties

childResources → Set<Resource>: finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>: latefinalinherited
creationTimestamp ↔ Output<String>: Creation timestamp in RFC3339 text format.
latefinal
deletionPolicy ↔ Output<String>: Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
latefinal
description ↔ Output<String?>: An optional description of this resource. Provide this property when you create the resource.
latefinal
fingerprint ↔ Output<String>: Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a CompositeHealthCheck. An up-to-date fingerprint must be provided in order to patch the CompositeHealthCheck; Otherwise, the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve the CompositeHealthCheck.
latefinal
hashCode → int: The hash code for this object.
no setterinherited
healthDestination ↔ Output<String>: URL to the destination resource. Must be set. Must be a ForwardingRule. The ForwardingRule must have load balancing scheme INTERNAL or INTERNAL_MANAGED and must be regional and in the same region as the CompositeHealthCheck (cross-region deployment for INTERNAL_MANAGED is not supported). Can be mutated.
latefinal
healthSources ↔ Output<List<String>?>: URLs to the HealthSource resources whose results are AND'ed. I.e. he aggregated result is is HEALTHY only if all sources are HEALTHY. Must have at least 1. Must not have more than 10. Must be regional and in the same region as the CompositeHealthCheck. Can be mutated.
latefinal
id ↔ Output<String>: getter/setter pairinherited
isCustom → bool: Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool: Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool: Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool: Whether this instance represents a resource value returned over RPC.
finalinherited
name ↔ Output<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. Specifically, the name must be 1-63 characters long and match the regular expression a-z? which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash.
latefinal
project ↔ Output<String>: The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
latefinal
region ↔ Output<String>: URL of the region where the composite health check resides.
latefinal
resourceTransforms → List<ResourceTransform>: Inherited/explicit async transforms.
no setterinherited
runtimeType → Type: A representation of the runtime type of the object.
no setterinherited
selfLinkWithId ↔ Output<String>: Server-defined URL with id for the resource.
latefinal
transformations → List<ResourceTransformation>: Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>: latefinalinherited

Methods

failId(Object error) → void: Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void: Completes all output properties with error.
inherited
failUrn(Object error) → void: Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?: Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String: Returns this resource's logical name.
inherited
getResourceType() → String: Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic: Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>: Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void: Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void: Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void: Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>: Serializes resource properties for RPC transmission.
inherited
toString() → String: A string representation of this object.
inherited

Operators

operator ==(Object other) → bool: The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {RegionCompositeHealthCheckState? state, CustomResourceOptions? options}) → RegionCompositeHealthCheck: Gets an existing RegionCompositeHealthCheck resource's state with the given name and id.