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

RegionBackendServiceArgs

data class RegionBackendServiceArgs(val affinityCookieTtlSec: Output<Int>? = null, val backends: Output<List<RegionBackendServiceBackendArgs>>? = null, val cdnPolicy: Output<RegionBackendServiceCdnPolicyArgs>? = null, val circuitBreakers: Output<RegionBackendServiceCircuitBreakersArgs>? = null, val connectionDrainingTimeoutSec: Output<Int>? = null, val connectionTrackingPolicy: Output<RegionBackendServiceConnectionTrackingPolicyArgs>? = null, val consistentHash: Output<RegionBackendServiceConsistentHashArgs>? = null, val description: Output<String>? = null, val enableCdn: Output<Boolean>? = null, val failoverPolicy: Output<RegionBackendServiceFailoverPolicyArgs>? = null, val healthChecks: Output<String>? = null, val iap: Output<RegionBackendServiceIapArgs>? = null, val loadBalancingScheme: Output<String>? = null, val localityLbPolicy: Output<String>? = null, val logConfig: Output<RegionBackendServiceLogConfigArgs>? = null, val name: Output<String>? = null, val network: Output<String>? = null, val outlierDetection: Output<RegionBackendServiceOutlierDetectionArgs>? = null, val portName: Output<String>? = null, val project: Output<String>? = null, val protocol: Output<String>? = null, val region: Output<String>? = null, val securityPolicy: Output<String>? = null, val sessionAffinity: Output<String>? = null, val subsetting: Output<RegionBackendServiceSubsettingArgs>? = null, val timeoutSec: Output<Int>? = null) : ConvertibleToJava<RegionBackendServiceArgs>

A Region Backend Service defines a regionally-scoped group of virtual machines that will serve traffic for load balancing. To get more information about RegionBackendService, see:

Warning: All arguments including the following potentially sensitive values will be stored in the raw state as plain text: iap.oauth2_client_secret, iap.oauth2_client_secret_sha256. Read more about sensitive data in state.

Example Usage

Region Backend Service Basic

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HealthCheck;
import com.pulumi.gcp.compute.HealthCheckArgs;
import com.pulumi.gcp.compute.inputs.HealthCheckTcpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var defaultHealthCheck = new HealthCheck("defaultHealthCheck", HealthCheckArgs.builder()
            .checkIntervalSec(1)
            .timeoutSec(1)
            .tcpHealthCheck(HealthCheckTcpHealthCheckArgs.builder()
                .port("80")
                .build())
            .build());
        var defaultRegionBackendService = new RegionBackendService("defaultRegionBackendService", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .healthChecks(defaultHealthCheck.id())
            .connectionDrainingTimeoutSec(10)
            .sessionAffinity("CLIENT_IP")
            .build());
    }
}
Content copied to clipboard

Region Backend Service Cache

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.gcp.compute.inputs.RegionBackendServiceCdnPolicyArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var defaultRegionHealthCheck = new RegionHealthCheck("defaultRegionHealthCheck", RegionHealthCheckArgs.builder()
            .region("us-central1")
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var defaultRegionBackendService = new RegionBackendService("defaultRegionBackendService", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .healthChecks(defaultRegionHealthCheck.id())
            .enableCdn(true)
            .cdnPolicy(RegionBackendServiceCdnPolicyArgs.builder()
                .cacheMode("CACHE_ALL_STATIC")
                .defaultTtl(3600)
                .clientTtl(7200)
                .maxTtl(10800)
                .negativeCaching(true)
                .signedUrlCacheMaxAgeSec(7200)
                .build())
            .loadBalancingScheme("EXTERNAL")
            .protocol("HTTP")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
    }
}
Content copied to clipboard

Region Backend Service Ilb Round Robin

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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 java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var healthCheck = new HealthCheck("healthCheck", HealthCheckArgs.builder()
            .httpHealthCheck(HealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
        var default_ = new RegionBackendService("default", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .healthChecks(healthCheck.id())
            .protocol("HTTP")
            .loadBalancingScheme("INTERNAL_MANAGED")
            .localityLbPolicy("ROUND_ROBIN")
            .build());
    }
}
Content copied to clipboard

Region Backend Service External

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckTcpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var healthCheck = new RegionHealthCheck("healthCheck", RegionHealthCheckArgs.builder()
            .region("us-central1")
            .tcpHealthCheck(RegionHealthCheckTcpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var default_ = new RegionBackendService("default", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .healthChecks(healthCheck.id())
            .protocol("TCP")
            .loadBalancingScheme("EXTERNAL")
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
    }
}
Content copied to clipboard

Region Backend Service External Weighted

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var healthCheck = new RegionHealthCheck("healthCheck", RegionHealthCheckArgs.builder()
            .region("us-central1")
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
        var default_ = new RegionBackendService("default", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .healthChecks(healthCheck.id())
            .protocol("TCP")
            .loadBalancingScheme("EXTERNAL")
            .localityLbPolicy("WEIGHTED_MAGLEV")
            .build());
    }
}
Content copied to clipboard

Region Backend Service Ilb Ring Hash

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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.inputs.RegionBackendServiceCircuitBreakersArgs;
import com.pulumi.gcp.compute.inputs.RegionBackendServiceConsistentHashArgs;
import com.pulumi.gcp.compute.inputs.RegionBackendServiceConsistentHashHttpCookieArgs;
import com.pulumi.gcp.compute.inputs.RegionBackendServiceConsistentHashHttpCookieTtlArgs;
import com.pulumi.gcp.compute.inputs.RegionBackendServiceOutlierDetectionArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var healthCheck = new HealthCheck("healthCheck", HealthCheckArgs.builder()
            .httpHealthCheck(HealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
        var default_ = new RegionBackendService("default", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .healthChecks(healthCheck.id())
            .loadBalancingScheme("INTERNAL_MANAGED")
            .localityLbPolicy("RING_HASH")
            .sessionAffinity("HTTP_COOKIE")
            .protocol("HTTP")
            .circuitBreakers(RegionBackendServiceCircuitBreakersArgs.builder()
                .maxConnections(10)
                .build())
            .consistentHash(RegionBackendServiceConsistentHashArgs.builder()
                .httpCookie(RegionBackendServiceConsistentHashHttpCookieArgs.builder()
                    .ttl(RegionBackendServiceConsistentHashHttpCookieTtlArgs.builder()
                        .seconds(11)
                        .nanos(1111)
                        .build())
                    .name("mycookie")
                    .build())
                .build())
            .outlierDetection(RegionBackendServiceOutlierDetectionArgs.builder()
                .consecutiveErrors(2)
                .build())
            .build());
    }
}
Content copied to clipboard

Region Backend Service Balancing Mode

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.ComputeFunctions;
import com.pulumi.gcp.compute.inputs.GetImageArgs;
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.InstanceTemplate;
import com.pulumi.gcp.compute.InstanceTemplateArgs;
import com.pulumi.gcp.compute.inputs.InstanceTemplateNetworkInterfaceArgs;
import com.pulumi.gcp.compute.inputs.InstanceTemplateDiskArgs;
import com.pulumi.gcp.compute.RegionInstanceGroupManager;
import com.pulumi.gcp.compute.RegionInstanceGroupManagerArgs;
import com.pulumi.gcp.compute.inputs.RegionInstanceGroupManagerVersionArgs;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.gcp.compute.inputs.RegionBackendServiceBackendArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        final var debianImage = ComputeFunctions.getImage(GetImageArgs.builder()
            .family("debian-11")
            .project("debian-cloud")
            .build());
        var defaultNetwork = new Network("defaultNetwork", NetworkArgs.builder()
            .autoCreateSubnetworks(false)
            .routingMode("REGIONAL")
            .build());
        var defaultSubnetwork = new Subnetwork("defaultSubnetwork", SubnetworkArgs.builder()
            .ipCidrRange("10.1.2.0/24")
            .region("us-central1")
            .network(defaultNetwork.id())
            .build());
        var instanceTemplate = new InstanceTemplate("instanceTemplate", InstanceTemplateArgs.builder()
            .machineType("e2-medium")
            .networkInterfaces(InstanceTemplateNetworkInterfaceArgs.builder()
                .network(defaultNetwork.id())
                .subnetwork(defaultSubnetwork.id())
                .build())
            .disks(InstanceTemplateDiskArgs.builder()
                .sourceImage(debianImage.applyValue(getImageResult -> getImageResult.selfLink()))
                .autoDelete(true)
                .boot(true)
                .build())
            .tags(
                "allow-ssh",
                "load-balanced-backend")
            .build());
        var rigm = new RegionInstanceGroupManager("rigm", RegionInstanceGroupManagerArgs.builder()
            .region("us-central1")
            .versions(RegionInstanceGroupManagerVersionArgs.builder()
                .instanceTemplate(instanceTemplate.id())
                .name("primary")
                .build())
            .baseInstanceName("internal-glb")
            .targetSize(1)
            .build());
        var defaultRegionHealthCheck = new RegionHealthCheck("defaultRegionHealthCheck", RegionHealthCheckArgs.builder()
            .region("us-central1")
            .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                .portSpecification("USE_SERVING_PORT")
                .build())
            .build());
        var defaultRegionBackendService = new RegionBackendService("defaultRegionBackendService", RegionBackendServiceArgs.builder()
            .loadBalancingScheme("INTERNAL_MANAGED")
            .backends(RegionBackendServiceBackendArgs.builder()
                .group(rigm.instanceGroup())
                .balancingMode("UTILIZATION")
                .capacityScaler(1)
                .build())
            .region("us-central1")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(defaultRegionHealthCheck.id())
            .build());
    }
}
Content copied to clipboard

Region Backend Service Connection Tracking

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.RegionHealthCheck;
import com.pulumi.gcp.compute.RegionHealthCheckArgs;
import com.pulumi.gcp.compute.inputs.RegionHealthCheckTcpHealthCheckArgs;
import com.pulumi.gcp.compute.RegionBackendService;
import com.pulumi.gcp.compute.RegionBackendServiceArgs;
import com.pulumi.gcp.compute.inputs.RegionBackendServiceConnectionTrackingPolicyArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var healthCheck = new RegionHealthCheck("healthCheck", RegionHealthCheckArgs.builder()
            .region("us-central1")
            .tcpHealthCheck(RegionHealthCheckTcpHealthCheckArgs.builder()
                .port(22)
                .build())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
        var default_ = new RegionBackendService("default", RegionBackendServiceArgs.builder()
            .region("us-central1")
            .healthChecks(healthCheck.id())
            .connectionDrainingTimeoutSec(10)
            .sessionAffinity("CLIENT_IP")
            .protocol("TCP")
            .loadBalancingScheme("EXTERNAL")
            .connectionTrackingPolicy(RegionBackendServiceConnectionTrackingPolicyArgs.builder()
                .trackingMode("PER_SESSION")
                .connectionPersistenceOnUnhealthyBackends("NEVER_PERSIST")
                .idleTimeoutSec(60)
                .enableStrongAffinity(true)
                .build())
            .build(), CustomResourceOptions.builder()
                .provider(google_beta)
                .build());
    }
}
Content copied to clipboard

Import

RegionBackendService can be imported using any of these accepted formats

$ pulumi import gcp:compute/regionBackendService:RegionBackendService default projects/{{project}}/regions/{{region}}/backendServices/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/regionBackendService:RegionBackendService default {{project}}/{{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/regionBackendService:RegionBackendService default {{region}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/regionBackendService:RegionBackendService default {{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
fun RegionBackendServiceArgs(affinityCookieTtlSec: Output<Int>? = null, backends: Output<List<RegionBackendServiceBackendArgs>>? = null, cdnPolicy: Output<RegionBackendServiceCdnPolicyArgs>? = null, circuitBreakers: Output<RegionBackendServiceCircuitBreakersArgs>? = null, connectionDrainingTimeoutSec: Output<Int>? = null, connectionTrackingPolicy: Output<RegionBackendServiceConnectionTrackingPolicyArgs>? = null, consistentHash: Output<RegionBackendServiceConsistentHashArgs>? = null, description: Output<String>? = null, enableCdn: Output<Boolean>? = null, failoverPolicy: Output<RegionBackendServiceFailoverPolicyArgs>? = null, healthChecks: Output<String>? = null, iap: Output<RegionBackendServiceIapArgs>? = null, loadBalancingScheme: Output<String>? = null, localityLbPolicy: Output<String>? = null, logConfig: Output<RegionBackendServiceLogConfigArgs>? = null, name: Output<String>? = null, network: Output<String>? = null, outlierDetection: Output<RegionBackendServiceOutlierDetectionArgs>? = null, portName: Output<String>? = null, project: Output<String>? = null, protocol: Output<String>? = null, region: Output<String>? = null, securityPolicy: Output<String>? = null, sessionAffinity: Output<String>? = null, subsetting: Output<RegionBackendServiceSubsettingArgs>? = null, timeoutSec: Output<Int>? = null)

Functions

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

Properties

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

Lifetime of cookies in seconds if session_affinity is GENERATED_COOKIE. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value for TTL is one day. When the load balancing scheme is INTERNAL, this field is not used.

Link copied to clipboard
val backends: Output<List<RegionBackendServiceBackendArgs>>? = null

The set of backends that serve this RegionBackendService. Structure is documented below.

Link copied to clipboard
val cdnPolicy: Output<RegionBackendServiceCdnPolicyArgs>? = null

Cloud CDN configuration for this BackendService. Structure is documented below.

Link copied to clipboard
val circuitBreakers: Output<RegionBackendServiceCircuitBreakersArgs>? = null

Settings controlling the volume of connections to a backend service. This field is applicable only when the load_balancing_scheme is set to INTERNAL_MANAGED and the protocol is set to HTTP, HTTPS, or HTTP2. Structure is documented below.

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

Time for which instance will be drained (not accept new connections, but still work to finish started).

Link copied to clipboard
val connectionTrackingPolicy: Output<RegionBackendServiceConnectionTrackingPolicyArgs>? = null

Connection Tracking configuration for this BackendService. This is available only for Layer 4 Internal Load Balancing and Network Load Balancing. Structure is documented below.

Link copied to clipboard
val consistentHash: Output<RegionBackendServiceConsistentHashArgs>? = null

Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field only applies when all of the following are true -

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

An optional description of this resource.

Link copied to clipboard
val enableCdn: Output<Boolean>? = null

If true, enable Cloud CDN for this RegionBackendService.

Link copied to clipboard
val failoverPolicy: Output<RegionBackendServiceFailoverPolicyArgs>? = null

Policy for failovers. Structure is documented below.

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

The set of URLs to HealthCheck resources for health checking this RegionBackendService. Currently at most one health check can be specified. A health check must be specified unless the backend service uses an internet or serverless NEG as a backend.

Link copied to clipboard
val iap: Output<RegionBackendServiceIapArgs>? = null

Settings for enabling Cloud Identity Aware Proxy Structure is documented below.

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

Indicates what kind of load balancing this regional backend service will be used for. A backend service created for one type of load balancing cannot be used with the other(s). For more information, refer to Choosing a load balancer. Default value is INTERNAL. Possible values are: EXTERNAL, EXTERNAL_MANAGED, INTERNAL, INTERNAL_MANAGED.

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

The load balancing algorithm used within the scope of the locality. The possible values are:

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

This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. Structure is documented below.

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

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

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

The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL.

Link copied to clipboard
val outlierDetection: Output<RegionBackendServiceOutlierDetectionArgs>? = null

Settings controlling eviction of unhealthy hosts from the load balancing pool. This field is applicable only when the load_balancing_scheme is set to INTERNAL_MANAGED and the protocol is set to HTTP, HTTPS, or HTTP2. Structure is documented below.

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

A named port on a backend instance group representing the port for communication to the backend VMs in that group. Required when the loadBalancingScheme is EXTERNAL, EXTERNAL_MANAGED, INTERNAL_MANAGED, or INTERNAL_SELF_MANAGED and the backends are instance groups. The named port must be defined on each backend instance group. This parameter has no meaning if the backends are NEGs. API sets a default of "http" if not given. Must be omitted when the loadBalancingScheme is INTERNAL (Internal TCP/UDP Load Balancing).

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

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

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

The protocol this RegionBackendService uses to communicate with backends. The default is HTTP. NOTE: HTTP2 is only valid for beta HTTP/2 load balancer types and may result in errors if used with the GA API. Possible values are: HTTP, HTTPS, HTTP2, SSL, TCP, UDP, GRPC, UNSPECIFIED.

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

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

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

The security policy associated with this backend service.

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

Type of session affinity to use. The default is NONE. Session affinity is not applicable if the protocol is UDP. Possible values are: NONE, CLIENT_IP, CLIENT_IP_PORT_PROTO, CLIENT_IP_PROTO, GENERATED_COOKIE, HEADER_FIELD, HTTP_COOKIE, CLIENT_IP_NO_DESTINATION.

Link copied to clipboard
val subsetting: Output<RegionBackendServiceSubsettingArgs>? = null

Subsetting configuration for this BackendService. Currently this is applicable only for Internal TCP/UDP load balancing and Internal HTTP(S) load balancing.

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

How many seconds to wait for the backend before considering it a failed request. Default is 30 seconds. Valid range is 1, 86400.