1. Packages
  2. Google Cloud (GCP) Classic
  3. API Docs
  4. compute
  5. RegionUrlMap
Google Cloud Classic v7.28.0 published on Friday, Jun 21, 2024 by Pulumi

gcp.compute.RegionUrlMap

Explore with Pulumi AI

gcp logo
Google Cloud Classic v7.28.0 published on Friday, Jun 21, 2024 by Pulumi

    UrlMaps are used to route requests to a backend service based on rules that you define for the host and path of an incoming URL.

    Example Usage

    Region Url Map Basic

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.compute.RegionHealthCheck("default", {
        region: "us-central1",
        name: "health-check",
        checkIntervalSec: 1,
        timeoutSec: 1,
        httpHealthCheck: {
            port: 80,
            requestPath: "/",
        },
    });
    const login = new gcp.compute.RegionBackendService("login", {
        region: "us-central1",
        name: "login",
        protocol: "HTTP",
        loadBalancingScheme: "INTERNAL_MANAGED",
        timeoutSec: 10,
        healthChecks: _default.id,
    });
    const home = new gcp.compute.RegionBackendService("home", {
        region: "us-central1",
        name: "home",
        protocol: "HTTP",
        loadBalancingScheme: "INTERNAL_MANAGED",
        timeoutSec: 10,
        healthChecks: _default.id,
    });
    const regionurlmap = new gcp.compute.RegionUrlMap("regionurlmap", {
        region: "us-central1",
        name: "regionurlmap",
        description: "a description",
        defaultService: home.id,
        hostRules: [{
            hosts: ["mysite.com"],
            pathMatcher: "allpaths",
        }],
        pathMatchers: [{
            name: "allpaths",
            defaultService: home.id,
            pathRules: [
                {
                    paths: ["/home"],
                    service: home.id,
                },
                {
                    paths: ["/login"],
                    service: login.id,
                },
            ],
        }],
        tests: [{
            service: home.id,
            host: "hi.com",
            path: "/home",
        }],
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.compute.RegionHealthCheck("default",
        region="us-central1",
        name="health-check",
        check_interval_sec=1,
        timeout_sec=1,
        http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
            port=80,
            request_path="/",
        ))
    login = gcp.compute.RegionBackendService("login",
        region="us-central1",
        name="login",
        protocol="HTTP",
        load_balancing_scheme="INTERNAL_MANAGED",
        timeout_sec=10,
        health_checks=default.id)
    home = gcp.compute.RegionBackendService("home",
        region="us-central1",
        name="home",
        protocol="HTTP",
        load_balancing_scheme="INTERNAL_MANAGED",
        timeout_sec=10,
        health_checks=default.id)
    regionurlmap = gcp.compute.RegionUrlMap("regionurlmap",
        region="us-central1",
        name="regionurlmap",
        description="a description",
        default_service=home.id,
        host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
            hosts=["mysite.com"],
            path_matcher="allpaths",
        )],
        path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
            name="allpaths",
            default_service=home.id,
            path_rules=[
                gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
                    paths=["/home"],
                    service=home.id,
                ),
                gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
                    paths=["/login"],
                    service=login.id,
                ),
            ],
        )],
        tests=[gcp.compute.RegionUrlMapTestArgs(
            service=home.id,
            host="hi.com",
            path="/home",
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
    			Region:           pulumi.String("us-central1"),
    			Name:             pulumi.String("health-check"),
    			CheckIntervalSec: pulumi.Int(1),
    			TimeoutSec:       pulumi.Int(1),
    			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
    				Port:        pulumi.Int(80),
    				RequestPath: pulumi.String("/"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		login, err := compute.NewRegionBackendService(ctx, "login", &compute.RegionBackendServiceArgs{
    			Region:              pulumi.String("us-central1"),
    			Name:                pulumi.String("login"),
    			Protocol:            pulumi.String("HTTP"),
    			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        _default.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		home, err := compute.NewRegionBackendService(ctx, "home", &compute.RegionBackendServiceArgs{
    			Region:              pulumi.String("us-central1"),
    			Name:                pulumi.String("home"),
    			Protocol:            pulumi.String("HTTP"),
    			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        _default.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionUrlMap(ctx, "regionurlmap", &compute.RegionUrlMapArgs{
    			Region:         pulumi.String("us-central1"),
    			Name:           pulumi.String("regionurlmap"),
    			Description:    pulumi.String("a description"),
    			DefaultService: home.ID(),
    			HostRules: compute.RegionUrlMapHostRuleArray{
    				&compute.RegionUrlMapHostRuleArgs{
    					Hosts: pulumi.StringArray{
    						pulumi.String("mysite.com"),
    					},
    					PathMatcher: pulumi.String("allpaths"),
    				},
    			},
    			PathMatchers: compute.RegionUrlMapPathMatcherArray{
    				&compute.RegionUrlMapPathMatcherArgs{
    					Name:           pulumi.String("allpaths"),
    					DefaultService: home.ID(),
    					PathRules: compute.RegionUrlMapPathMatcherPathRuleArray{
    						&compute.RegionUrlMapPathMatcherPathRuleArgs{
    							Paths: pulumi.StringArray{
    								pulumi.String("/home"),
    							},
    							Service: home.ID(),
    						},
    						&compute.RegionUrlMapPathMatcherPathRuleArgs{
    							Paths: pulumi.StringArray{
    								pulumi.String("/login"),
    							},
    							Service: login.ID(),
    						},
    					},
    				},
    			},
    			Tests: compute.RegionUrlMapTestArray{
    				&compute.RegionUrlMapTestArgs{
    					Service: home.ID(),
    					Host:    pulumi.String("hi.com"),
    					Path:    pulumi.String("/home"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var @default = new Gcp.Compute.RegionHealthCheck("default", new()
        {
            Region = "us-central1",
            Name = "health-check",
            CheckIntervalSec = 1,
            TimeoutSec = 1,
            HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
            {
                Port = 80,
                RequestPath = "/",
            },
        });
    
        var login = new Gcp.Compute.RegionBackendService("login", new()
        {
            Region = "us-central1",
            Name = "login",
            Protocol = "HTTP",
            LoadBalancingScheme = "INTERNAL_MANAGED",
            TimeoutSec = 10,
            HealthChecks = @default.Id,
        });
    
        var home = new Gcp.Compute.RegionBackendService("home", new()
        {
            Region = "us-central1",
            Name = "home",
            Protocol = "HTTP",
            LoadBalancingScheme = "INTERNAL_MANAGED",
            TimeoutSec = 10,
            HealthChecks = @default.Id,
        });
    
        var regionurlmap = new Gcp.Compute.RegionUrlMap("regionurlmap", new()
        {
            Region = "us-central1",
            Name = "regionurlmap",
            Description = "a description",
            DefaultService = home.Id,
            HostRules = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
                {
                    Hosts = new[]
                    {
                        "mysite.com",
                    },
                    PathMatcher = "allpaths",
                },
            },
            PathMatchers = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
                {
                    Name = "allpaths",
                    DefaultService = home.Id,
                    PathRules = new[]
                    {
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                        {
                            Paths = new[]
                            {
                                "/home",
                            },
                            Service = home.Id,
                        },
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                        {
                            Paths = new[]
                            {
                                "/login",
                            },
                            Service = login.Id,
                        },
                    },
                },
            },
            Tests = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapTestArgs
                {
                    Service = home.Id,
                    Host = "hi.com",
                    Path = "/home",
                },
            },
        });
    
    });
    
    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.RegionUrlMap;
    import com.pulumi.gcp.compute.RegionUrlMapArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapTestArgs;
    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 default_ = new RegionHealthCheck("default", RegionHealthCheckArgs.builder()
                .region("us-central1")
                .name("health-check")
                .checkIntervalSec(1)
                .timeoutSec(1)
                .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                    .port(80)
                    .requestPath("/")
                    .build())
                .build());
    
            var login = new RegionBackendService("login", RegionBackendServiceArgs.builder()
                .region("us-central1")
                .name("login")
                .protocol("HTTP")
                .loadBalancingScheme("INTERNAL_MANAGED")
                .timeoutSec(10)
                .healthChecks(default_.id())
                .build());
    
            var home = new RegionBackendService("home", RegionBackendServiceArgs.builder()
                .region("us-central1")
                .name("home")
                .protocol("HTTP")
                .loadBalancingScheme("INTERNAL_MANAGED")
                .timeoutSec(10)
                .healthChecks(default_.id())
                .build());
    
            var regionurlmap = new RegionUrlMap("regionurlmap", RegionUrlMapArgs.builder()
                .region("us-central1")
                .name("regionurlmap")
                .description("a description")
                .defaultService(home.id())
                .hostRules(RegionUrlMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("allpaths")
                    .build())
                .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                    .name("allpaths")
                    .defaultService(home.id())
                    .pathRules(                
                        RegionUrlMapPathMatcherPathRuleArgs.builder()
                            .paths("/home")
                            .service(home.id())
                            .build(),
                        RegionUrlMapPathMatcherPathRuleArgs.builder()
                            .paths("/login")
                            .service(login.id())
                            .build())
                    .build())
                .tests(RegionUrlMapTestArgs.builder()
                    .service(home.id())
                    .host("hi.com")
                    .path("/home")
                    .build())
                .build());
    
        }
    }
    
    resources:
      regionurlmap:
        type: gcp:compute:RegionUrlMap
        properties:
          region: us-central1
          name: regionurlmap
          description: a description
          defaultService: ${home.id}
          hostRules:
            - hosts:
                - mysite.com
              pathMatcher: allpaths
          pathMatchers:
            - name: allpaths
              defaultService: ${home.id}
              pathRules:
                - paths:
                    - /home
                  service: ${home.id}
                - paths:
                    - /login
                  service: ${login.id}
          tests:
            - service: ${home.id}
              host: hi.com
              path: /home
      login:
        type: gcp:compute:RegionBackendService
        properties:
          region: us-central1
          name: login
          protocol: HTTP
          loadBalancingScheme: INTERNAL_MANAGED
          timeoutSec: 10
          healthChecks: ${default.id}
      home:
        type: gcp:compute:RegionBackendService
        properties:
          region: us-central1
          name: home
          protocol: HTTP
          loadBalancingScheme: INTERNAL_MANAGED
          timeoutSec: 10
          healthChecks: ${default.id}
      default:
        type: gcp:compute:RegionHealthCheck
        properties:
          region: us-central1
          name: health-check
          checkIntervalSec: 1
          timeoutSec: 1
          httpHealthCheck:
            port: 80
            requestPath: /
    

    Region Url Map Default Route Action

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.compute.RegionHealthCheck("default", {
        region: "us-central1",
        name: "health-check",
        checkIntervalSec: 1,
        timeoutSec: 1,
        httpHealthCheck: {
            port: 80,
            requestPath: "/",
        },
    });
    const login = new gcp.compute.RegionBackendService("login", {
        region: "us-central1",
        name: "login",
        protocol: "HTTP",
        loadBalancingScheme: "INTERNAL_MANAGED",
        timeoutSec: 10,
        healthChecks: _default.id,
    });
    const home = new gcp.compute.RegionBackendService("home", {
        region: "us-central1",
        name: "home",
        protocol: "HTTP",
        loadBalancingScheme: "INTERNAL_MANAGED",
        timeoutSec: 10,
        healthChecks: _default.id,
    });
    const regionurlmap = new gcp.compute.RegionUrlMap("regionurlmap", {
        region: "us-central1",
        name: "regionurlmap",
        description: "a description",
        defaultRouteAction: {
            retryPolicy: {
                retryConditions: [
                    "5xx",
                    "gateway-error",
                ],
                numRetries: 3,
                perTryTimeout: {
                    seconds: "0",
                    nanos: 500,
                },
            },
            requestMirrorPolicy: {
                backendService: home.id,
            },
            weightedBackendServices: [
                {
                    backendService: login.id,
                    weight: 200,
                    headerAction: {
                        requestHeadersToAdds: [{
                            headerName: "foo-request-1",
                            headerValue: "bar",
                            replace: true,
                        }],
                        requestHeadersToRemoves: ["fizz"],
                        responseHeadersToAdds: [{
                            headerName: "foo-response-1",
                            headerValue: "bar",
                            replace: true,
                        }],
                        responseHeadersToRemoves: ["buzz"],
                    },
                },
                {
                    backendService: home.id,
                    weight: 100,
                    headerAction: {
                        requestHeadersToAdds: [
                            {
                                headerName: "foo-request-1",
                                headerValue: "bar",
                                replace: true,
                            },
                            {
                                headerName: "foo-request-2",
                                headerValue: "bar",
                                replace: true,
                            },
                        ],
                        requestHeadersToRemoves: ["fizz"],
                        responseHeadersToAdds: [
                            {
                                headerName: "foo-response-2",
                                headerValue: "bar",
                                replace: true,
                            },
                            {
                                headerName: "foo-response-1",
                                headerValue: "bar",
                                replace: true,
                            },
                        ],
                        responseHeadersToRemoves: ["buzz"],
                    },
                },
            ],
            urlRewrite: {
                hostRewrite: "dev.example.com",
                pathPrefixRewrite: "/v1/api/",
            },
            corsPolicy: {
                disabled: false,
                allowCredentials: true,
                allowHeaders: ["foobar"],
                allowMethods: [
                    "GET",
                    "POST",
                ],
                allowOrigins: ["example.com"],
                exposeHeaders: ["foobar"],
                maxAge: 60,
            },
            faultInjectionPolicy: {
                delay: {
                    fixedDelay: {
                        seconds: "0",
                        nanos: 500,
                    },
                    percentage: 0.5,
                },
                abort: {
                    httpStatus: 500,
                    percentage: 0.5,
                },
            },
            timeout: {
                seconds: "0",
                nanos: 500,
            },
        },
        hostRules: [{
            hosts: ["mysite.com"],
            pathMatcher: "allpaths",
        }],
        pathMatchers: [{
            name: "allpaths",
            defaultService: home.id,
            pathRules: [
                {
                    paths: ["/home"],
                    service: home.id,
                },
                {
                    paths: ["/login"],
                    service: login.id,
                },
            ],
        }],
        tests: [{
            service: home.id,
            host: "hi.com",
            path: "/home",
        }],
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.compute.RegionHealthCheck("default",
        region="us-central1",
        name="health-check",
        check_interval_sec=1,
        timeout_sec=1,
        http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
            port=80,
            request_path="/",
        ))
    login = gcp.compute.RegionBackendService("login",
        region="us-central1",
        name="login",
        protocol="HTTP",
        load_balancing_scheme="INTERNAL_MANAGED",
        timeout_sec=10,
        health_checks=default.id)
    home = gcp.compute.RegionBackendService("home",
        region="us-central1",
        name="home",
        protocol="HTTP",
        load_balancing_scheme="INTERNAL_MANAGED",
        timeout_sec=10,
        health_checks=default.id)
    regionurlmap = gcp.compute.RegionUrlMap("regionurlmap",
        region="us-central1",
        name="regionurlmap",
        description="a description",
        default_route_action=gcp.compute.RegionUrlMapDefaultRouteActionArgs(
            retry_policy=gcp.compute.RegionUrlMapDefaultRouteActionRetryPolicyArgs(
                retry_conditions=[
                    "5xx",
                    "gateway-error",
                ],
                num_retries=3,
                per_try_timeout=gcp.compute.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs(
                    seconds="0",
                    nanos=500,
                ),
            ),
            request_mirror_policy=gcp.compute.RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs(
                backend_service=home.id,
            ),
            weighted_backend_services=[
                gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs(
                    backend_service=login.id,
                    weight=200,
                    header_action=gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs(
                        request_headers_to_adds=[gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
                            header_name="foo-request-1",
                            header_value="bar",
                            replace=True,
                        )],
                        request_headers_to_removes=["fizz"],
                        response_headers_to_adds=[gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
                            header_name="foo-response-1",
                            header_value="bar",
                            replace=True,
                        )],
                        response_headers_to_removes=["buzz"],
                    ),
                ),
                gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs(
                    backend_service=home.id,
                    weight=100,
                    header_action=gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs(
                        request_headers_to_adds=[
                            gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
                                header_name="foo-request-1",
                                header_value="bar",
                                replace=True,
                            ),
                            gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
                                header_name="foo-request-2",
                                header_value="bar",
                                replace=True,
                            ),
                        ],
                        request_headers_to_removes=["fizz"],
                        response_headers_to_adds=[
                            gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
                                header_name="foo-response-2",
                                header_value="bar",
                                replace=True,
                            ),
                            gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
                                header_name="foo-response-1",
                                header_value="bar",
                                replace=True,
                            ),
                        ],
                        response_headers_to_removes=["buzz"],
                    ),
                ),
            ],
            url_rewrite=gcp.compute.RegionUrlMapDefaultRouteActionUrlRewriteArgs(
                host_rewrite="dev.example.com",
                path_prefix_rewrite="/v1/api/",
            ),
            cors_policy=gcp.compute.RegionUrlMapDefaultRouteActionCorsPolicyArgs(
                disabled=False,
                allow_credentials=True,
                allow_headers=["foobar"],
                allow_methods=[
                    "GET",
                    "POST",
                ],
                allow_origins=["example.com"],
                expose_headers=["foobar"],
                max_age=60,
            ),
            fault_injection_policy=gcp.compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs(
                delay=gcp.compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs(
                    fixed_delay=gcp.compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs(
                        seconds="0",
                        nanos=500,
                    ),
                    percentage=0.5,
                ),
                abort=gcp.compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs(
                    http_status=500,
                    percentage=0.5,
                ),
            ),
            timeout=gcp.compute.RegionUrlMapDefaultRouteActionTimeoutArgs(
                seconds="0",
                nanos=500,
            ),
        ),
        host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
            hosts=["mysite.com"],
            path_matcher="allpaths",
        )],
        path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
            name="allpaths",
            default_service=home.id,
            path_rules=[
                gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
                    paths=["/home"],
                    service=home.id,
                ),
                gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
                    paths=["/login"],
                    service=login.id,
                ),
            ],
        )],
        tests=[gcp.compute.RegionUrlMapTestArgs(
            service=home.id,
            host="hi.com",
            path="/home",
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
    			Region:           pulumi.String("us-central1"),
    			Name:             pulumi.String("health-check"),
    			CheckIntervalSec: pulumi.Int(1),
    			TimeoutSec:       pulumi.Int(1),
    			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
    				Port:        pulumi.Int(80),
    				RequestPath: pulumi.String("/"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		login, err := compute.NewRegionBackendService(ctx, "login", &compute.RegionBackendServiceArgs{
    			Region:              pulumi.String("us-central1"),
    			Name:                pulumi.String("login"),
    			Protocol:            pulumi.String("HTTP"),
    			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        _default.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		home, err := compute.NewRegionBackendService(ctx, "home", &compute.RegionBackendServiceArgs{
    			Region:              pulumi.String("us-central1"),
    			Name:                pulumi.String("home"),
    			Protocol:            pulumi.String("HTTP"),
    			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        _default.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionUrlMap(ctx, "regionurlmap", &compute.RegionUrlMapArgs{
    			Region:      pulumi.String("us-central1"),
    			Name:        pulumi.String("regionurlmap"),
    			Description: pulumi.String("a description"),
    			DefaultRouteAction: &compute.RegionUrlMapDefaultRouteActionArgs{
    				RetryPolicy: &compute.RegionUrlMapDefaultRouteActionRetryPolicyArgs{
    					RetryConditions: pulumi.StringArray{
    						pulumi.String("5xx"),
    						pulumi.String("gateway-error"),
    					},
    					NumRetries: pulumi.Int(3),
    					PerTryTimeout: &compute.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs{
    						Seconds: pulumi.String("0"),
    						Nanos:   pulumi.Int(500),
    					},
    				},
    				RequestMirrorPolicy: &compute.RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs{
    					BackendService: home.ID(),
    				},
    				WeightedBackendServices: compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceArray{
    					&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs{
    						BackendService: login.ID(),
    						Weight:         pulumi.Int(200),
    						HeaderAction: &compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs{
    							RequestHeadersToAdds: compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArray{
    								&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs{
    									HeaderName:  pulumi.String("foo-request-1"),
    									HeaderValue: pulumi.String("bar"),
    									Replace:     pulumi.Bool(true),
    								},
    							},
    							RequestHeadersToRemoves: pulumi.StringArray{
    								pulumi.String("fizz"),
    							},
    							ResponseHeadersToAdds: compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArray{
    								&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs{
    									HeaderName:  pulumi.String("foo-response-1"),
    									HeaderValue: pulumi.String("bar"),
    									Replace:     pulumi.Bool(true),
    								},
    							},
    							ResponseHeadersToRemoves: pulumi.StringArray{
    								pulumi.String("buzz"),
    							},
    						},
    					},
    					&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs{
    						BackendService: home.ID(),
    						Weight:         pulumi.Int(100),
    						HeaderAction: &compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs{
    							RequestHeadersToAdds: compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArray{
    								&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs{
    									HeaderName:  pulumi.String("foo-request-1"),
    									HeaderValue: pulumi.String("bar"),
    									Replace:     pulumi.Bool(true),
    								},
    								&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs{
    									HeaderName:  pulumi.String("foo-request-2"),
    									HeaderValue: pulumi.String("bar"),
    									Replace:     pulumi.Bool(true),
    								},
    							},
    							RequestHeadersToRemoves: pulumi.StringArray{
    								pulumi.String("fizz"),
    							},
    							ResponseHeadersToAdds: compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArray{
    								&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs{
    									HeaderName:  pulumi.String("foo-response-2"),
    									HeaderValue: pulumi.String("bar"),
    									Replace:     pulumi.Bool(true),
    								},
    								&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs{
    									HeaderName:  pulumi.String("foo-response-1"),
    									HeaderValue: pulumi.String("bar"),
    									Replace:     pulumi.Bool(true),
    								},
    							},
    							ResponseHeadersToRemoves: pulumi.StringArray{
    								pulumi.String("buzz"),
    							},
    						},
    					},
    				},
    				UrlRewrite: &compute.RegionUrlMapDefaultRouteActionUrlRewriteArgs{
    					HostRewrite:       pulumi.String("dev.example.com"),
    					PathPrefixRewrite: pulumi.String("/v1/api/"),
    				},
    				CorsPolicy: &compute.RegionUrlMapDefaultRouteActionCorsPolicyArgs{
    					Disabled:         pulumi.Bool(false),
    					AllowCredentials: pulumi.Bool(true),
    					AllowHeaders: pulumi.StringArray{
    						pulumi.String("foobar"),
    					},
    					AllowMethods: pulumi.StringArray{
    						pulumi.String("GET"),
    						pulumi.String("POST"),
    					},
    					AllowOrigins: pulumi.StringArray{
    						pulumi.String("example.com"),
    					},
    					ExposeHeaders: pulumi.StringArray{
    						pulumi.String("foobar"),
    					},
    					MaxAge: pulumi.Int(60),
    				},
    				FaultInjectionPolicy: &compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs{
    					Delay: &compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs{
    						FixedDelay: &compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs{
    							Seconds: pulumi.String("0"),
    							Nanos:   pulumi.Int(500),
    						},
    						Percentage: pulumi.Float64(0.5),
    					},
    					Abort: &compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs{
    						HttpStatus: pulumi.Int(500),
    						Percentage: pulumi.Float64(0.5),
    					},
    				},
    				Timeout: &compute.RegionUrlMapDefaultRouteActionTimeoutArgs{
    					Seconds: pulumi.String("0"),
    					Nanos:   pulumi.Int(500),
    				},
    			},
    			HostRules: compute.RegionUrlMapHostRuleArray{
    				&compute.RegionUrlMapHostRuleArgs{
    					Hosts: pulumi.StringArray{
    						pulumi.String("mysite.com"),
    					},
    					PathMatcher: pulumi.String("allpaths"),
    				},
    			},
    			PathMatchers: compute.RegionUrlMapPathMatcherArray{
    				&compute.RegionUrlMapPathMatcherArgs{
    					Name:           pulumi.String("allpaths"),
    					DefaultService: home.ID(),
    					PathRules: compute.RegionUrlMapPathMatcherPathRuleArray{
    						&compute.RegionUrlMapPathMatcherPathRuleArgs{
    							Paths: pulumi.StringArray{
    								pulumi.String("/home"),
    							},
    							Service: home.ID(),
    						},
    						&compute.RegionUrlMapPathMatcherPathRuleArgs{
    							Paths: pulumi.StringArray{
    								pulumi.String("/login"),
    							},
    							Service: login.ID(),
    						},
    					},
    				},
    			},
    			Tests: compute.RegionUrlMapTestArray{
    				&compute.RegionUrlMapTestArgs{
    					Service: home.ID(),
    					Host:    pulumi.String("hi.com"),
    					Path:    pulumi.String("/home"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var @default = new Gcp.Compute.RegionHealthCheck("default", new()
        {
            Region = "us-central1",
            Name = "health-check",
            CheckIntervalSec = 1,
            TimeoutSec = 1,
            HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
            {
                Port = 80,
                RequestPath = "/",
            },
        });
    
        var login = new Gcp.Compute.RegionBackendService("login", new()
        {
            Region = "us-central1",
            Name = "login",
            Protocol = "HTTP",
            LoadBalancingScheme = "INTERNAL_MANAGED",
            TimeoutSec = 10,
            HealthChecks = @default.Id,
        });
    
        var home = new Gcp.Compute.RegionBackendService("home", new()
        {
            Region = "us-central1",
            Name = "home",
            Protocol = "HTTP",
            LoadBalancingScheme = "INTERNAL_MANAGED",
            TimeoutSec = 10,
            HealthChecks = @default.Id,
        });
    
        var regionurlmap = new Gcp.Compute.RegionUrlMap("regionurlmap", new()
        {
            Region = "us-central1",
            Name = "regionurlmap",
            Description = "a description",
            DefaultRouteAction = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionArgs
            {
                RetryPolicy = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionRetryPolicyArgs
                {
                    RetryConditions = new[]
                    {
                        "5xx",
                        "gateway-error",
                    },
                    NumRetries = 3,
                    PerTryTimeout = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs
                    {
                        Seconds = "0",
                        Nanos = 500,
                    },
                },
                RequestMirrorPolicy = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs
                {
                    BackendService = home.Id,
                },
                WeightedBackendServices = new[]
                {
                    new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs
                    {
                        BackendService = login.Id,
                        Weight = 200,
                        HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs
                        {
                            RequestHeadersToAdds = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs
                                {
                                    HeaderName = "foo-request-1",
                                    HeaderValue = "bar",
                                    Replace = true,
                                },
                            },
                            RequestHeadersToRemoves = new[]
                            {
                                "fizz",
                            },
                            ResponseHeadersToAdds = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs
                                {
                                    HeaderName = "foo-response-1",
                                    HeaderValue = "bar",
                                    Replace = true,
                                },
                            },
                            ResponseHeadersToRemoves = new[]
                            {
                                "buzz",
                            },
                        },
                    },
                    new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs
                    {
                        BackendService = home.Id,
                        Weight = 100,
                        HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs
                        {
                            RequestHeadersToAdds = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs
                                {
                                    HeaderName = "foo-request-1",
                                    HeaderValue = "bar",
                                    Replace = true,
                                },
                                new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs
                                {
                                    HeaderName = "foo-request-2",
                                    HeaderValue = "bar",
                                    Replace = true,
                                },
                            },
                            RequestHeadersToRemoves = new[]
                            {
                                "fizz",
                            },
                            ResponseHeadersToAdds = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs
                                {
                                    HeaderName = "foo-response-2",
                                    HeaderValue = "bar",
                                    Replace = true,
                                },
                                new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs
                                {
                                    HeaderName = "foo-response-1",
                                    HeaderValue = "bar",
                                    Replace = true,
                                },
                            },
                            ResponseHeadersToRemoves = new[]
                            {
                                "buzz",
                            },
                        },
                    },
                },
                UrlRewrite = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionUrlRewriteArgs
                {
                    HostRewrite = "dev.example.com",
                    PathPrefixRewrite = "/v1/api/",
                },
                CorsPolicy = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionCorsPolicyArgs
                {
                    Disabled = false,
                    AllowCredentials = true,
                    AllowHeaders = new[]
                    {
                        "foobar",
                    },
                    AllowMethods = new[]
                    {
                        "GET",
                        "POST",
                    },
                    AllowOrigins = new[]
                    {
                        "example.com",
                    },
                    ExposeHeaders = new[]
                    {
                        "foobar",
                    },
                    MaxAge = 60,
                },
                FaultInjectionPolicy = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs
                {
                    Delay = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs
                    {
                        FixedDelay = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs
                        {
                            Seconds = "0",
                            Nanos = 500,
                        },
                        Percentage = 0.5,
                    },
                    Abort = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs
                    {
                        HttpStatus = 500,
                        Percentage = 0.5,
                    },
                },
                Timeout = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionTimeoutArgs
                {
                    Seconds = "0",
                    Nanos = 500,
                },
            },
            HostRules = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
                {
                    Hosts = new[]
                    {
                        "mysite.com",
                    },
                    PathMatcher = "allpaths",
                },
            },
            PathMatchers = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
                {
                    Name = "allpaths",
                    DefaultService = home.Id,
                    PathRules = new[]
                    {
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                        {
                            Paths = new[]
                            {
                                "/home",
                            },
                            Service = home.Id,
                        },
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                        {
                            Paths = new[]
                            {
                                "/login",
                            },
                            Service = login.Id,
                        },
                    },
                },
            },
            Tests = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapTestArgs
                {
                    Service = home.Id,
                    Host = "hi.com",
                    Path = "/home",
                },
            },
        });
    
    });
    
    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.RegionUrlMap;
    import com.pulumi.gcp.compute.RegionUrlMapArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionRetryPolicyArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionUrlRewriteArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionCorsPolicyArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapDefaultRouteActionTimeoutArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapTestArgs;
    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 default_ = new RegionHealthCheck("default", RegionHealthCheckArgs.builder()
                .region("us-central1")
                .name("health-check")
                .checkIntervalSec(1)
                .timeoutSec(1)
                .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                    .port(80)
                    .requestPath("/")
                    .build())
                .build());
    
            var login = new RegionBackendService("login", RegionBackendServiceArgs.builder()
                .region("us-central1")
                .name("login")
                .protocol("HTTP")
                .loadBalancingScheme("INTERNAL_MANAGED")
                .timeoutSec(10)
                .healthChecks(default_.id())
                .build());
    
            var home = new RegionBackendService("home", RegionBackendServiceArgs.builder()
                .region("us-central1")
                .name("home")
                .protocol("HTTP")
                .loadBalancingScheme("INTERNAL_MANAGED")
                .timeoutSec(10)
                .healthChecks(default_.id())
                .build());
    
            var regionurlmap = new RegionUrlMap("regionurlmap", RegionUrlMapArgs.builder()
                .region("us-central1")
                .name("regionurlmap")
                .description("a description")
                .defaultRouteAction(RegionUrlMapDefaultRouteActionArgs.builder()
                    .retryPolicy(RegionUrlMapDefaultRouteActionRetryPolicyArgs.builder()
                        .retryConditions(                    
                            "5xx",
                            "gateway-error")
                        .numRetries(3)
                        .perTryTimeout(RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs.builder()
                            .seconds(0)
                            .nanos(500)
                            .build())
                        .build())
                    .requestMirrorPolicy(RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs.builder()
                        .backendService(home.id())
                        .build())
                    .weightedBackendServices(                
                        RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs.builder()
                            .backendService(login.id())
                            .weight(200)
                            .headerAction(RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                                .requestHeadersToAdds(RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                                    .headerName("foo-request-1")
                                    .headerValue("bar")
                                    .replace(true)
                                    .build())
                                .requestHeadersToRemoves("fizz")
                                .responseHeadersToAdds(RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                    .headerName("foo-response-1")
                                    .headerValue("bar")
                                    .replace(true)
                                    .build())
                                .responseHeadersToRemoves("buzz")
                                .build())
                            .build(),
                        RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs.builder()
                            .backendService(home.id())
                            .weight(100)
                            .headerAction(RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                                .requestHeadersToAdds(                            
                                    RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                                        .headerName("foo-request-1")
                                        .headerValue("bar")
                                        .replace(true)
                                        .build(),
                                    RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                                        .headerName("foo-request-2")
                                        .headerValue("bar")
                                        .replace(true)
                                        .build())
                                .requestHeadersToRemoves("fizz")
                                .responseHeadersToAdds(                            
                                    RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                        .headerName("foo-response-2")
                                        .headerValue("bar")
                                        .replace(true)
                                        .build(),
                                    RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                        .headerName("foo-response-1")
                                        .headerValue("bar")
                                        .replace(true)
                                        .build())
                                .responseHeadersToRemoves("buzz")
                                .build())
                            .build())
                    .urlRewrite(RegionUrlMapDefaultRouteActionUrlRewriteArgs.builder()
                        .hostRewrite("dev.example.com")
                        .pathPrefixRewrite("/v1/api/")
                        .build())
                    .corsPolicy(RegionUrlMapDefaultRouteActionCorsPolicyArgs.builder()
                        .disabled(false)
                        .allowCredentials(true)
                        .allowHeaders("foobar")
                        .allowMethods(                    
                            "GET",
                            "POST")
                        .allowOrigins("example.com")
                        .exposeHeaders("foobar")
                        .maxAge(60)
                        .build())
                    .faultInjectionPolicy(RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs.builder()
                        .delay(RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs.builder()
                            .fixedDelay(RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs.builder()
                                .seconds(0)
                                .nanos(500)
                                .build())
                            .percentage(0.5)
                            .build())
                        .abort(RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs.builder()
                            .httpStatus(500)
                            .percentage(0.5)
                            .build())
                        .build())
                    .timeout(RegionUrlMapDefaultRouteActionTimeoutArgs.builder()
                        .seconds(0)
                        .nanos(500)
                        .build())
                    .build())
                .hostRules(RegionUrlMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("allpaths")
                    .build())
                .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                    .name("allpaths")
                    .defaultService(home.id())
                    .pathRules(                
                        RegionUrlMapPathMatcherPathRuleArgs.builder()
                            .paths("/home")
                            .service(home.id())
                            .build(),
                        RegionUrlMapPathMatcherPathRuleArgs.builder()
                            .paths("/login")
                            .service(login.id())
                            .build())
                    .build())
                .tests(RegionUrlMapTestArgs.builder()
                    .service(home.id())
                    .host("hi.com")
                    .path("/home")
                    .build())
                .build());
    
        }
    }
    
    resources:
      regionurlmap:
        type: gcp:compute:RegionUrlMap
        properties:
          region: us-central1
          name: regionurlmap
          description: a description
          defaultRouteAction:
            retryPolicy:
              retryConditions:
                - 5xx
                - gateway-error
              numRetries: 3
              perTryTimeout:
                seconds: 0
                nanos: 500
            requestMirrorPolicy:
              backendService: ${home.id}
            weightedBackendServices:
              - backendService: ${login.id}
                weight: 200
                headerAction:
                  requestHeadersToAdds:
                    - headerName: foo-request-1
                      headerValue: bar
                      replace: true
                  requestHeadersToRemoves:
                    - fizz
                  responseHeadersToAdds:
                    - headerName: foo-response-1
                      headerValue: bar
                      replace: true
                  responseHeadersToRemoves:
                    - buzz
              - backendService: ${home.id}
                weight: 100
                headerAction:
                  requestHeadersToAdds:
                    - headerName: foo-request-1
                      headerValue: bar
                      replace: true
                    - headerName: foo-request-2
                      headerValue: bar
                      replace: true
                  requestHeadersToRemoves:
                    - fizz
                  responseHeadersToAdds:
                    - headerName: foo-response-2
                      headerValue: bar
                      replace: true
                    - headerName: foo-response-1
                      headerValue: bar
                      replace: true
                  responseHeadersToRemoves:
                    - buzz
            urlRewrite:
              hostRewrite: dev.example.com
              pathPrefixRewrite: /v1/api/
            corsPolicy:
              disabled: false
              allowCredentials: true
              allowHeaders:
                - foobar
              allowMethods:
                - GET
                - POST
              allowOrigins:
                - example.com
              exposeHeaders:
                - foobar
              maxAge: 60
            faultInjectionPolicy:
              delay:
                fixedDelay:
                  seconds: 0
                  nanos: 500
                percentage: 0.5
              abort:
                httpStatus: 500
                percentage: 0.5
            timeout:
              seconds: 0
              nanos: 500
          hostRules:
            - hosts:
                - mysite.com
              pathMatcher: allpaths
          pathMatchers:
            - name: allpaths
              defaultService: ${home.id}
              pathRules:
                - paths:
                    - /home
                  service: ${home.id}
                - paths:
                    - /login
                  service: ${login.id}
          tests:
            - service: ${home.id}
              host: hi.com
              path: /home
      login:
        type: gcp:compute:RegionBackendService
        properties:
          region: us-central1
          name: login
          protocol: HTTP
          loadBalancingScheme: INTERNAL_MANAGED
          timeoutSec: 10
          healthChecks: ${default.id}
      home:
        type: gcp:compute:RegionBackendService
        properties:
          region: us-central1
          name: home
          protocol: HTTP
          loadBalancingScheme: INTERNAL_MANAGED
          timeoutSec: 10
          healthChecks: ${default.id}
      default:
        type: gcp:compute:RegionHealthCheck
        properties:
          region: us-central1
          name: health-check
          checkIntervalSec: 1
          timeoutSec: 1
          httpHealthCheck:
            port: 80
            requestPath: /
    

    Region Url Map L7 Ilb Path

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.compute.RegionHealthCheck("default", {
        name: "health-check",
        httpHealthCheck: {
            port: 80,
        },
    });
    const home = new gcp.compute.RegionBackendService("home", {
        name: "home",
        protocol: "HTTP",
        timeoutSec: 10,
        healthChecks: _default.id,
        loadBalancingScheme: "INTERNAL_MANAGED",
    });
    const regionurlmap = new gcp.compute.RegionUrlMap("regionurlmap", {
        name: "regionurlmap",
        description: "a description",
        defaultService: home.id,
        hostRules: [{
            hosts: ["mysite.com"],
            pathMatcher: "allpaths",
        }],
        pathMatchers: [{
            name: "allpaths",
            defaultService: home.id,
            pathRules: [{
                paths: ["/home"],
                routeAction: {
                    corsPolicy: {
                        allowCredentials: true,
                        allowHeaders: ["Allowed content"],
                        allowMethods: ["GET"],
                        allowOrigins: ["Allowed origin"],
                        exposeHeaders: ["Exposed header"],
                        maxAge: 30,
                        disabled: false,
                    },
                    faultInjectionPolicy: {
                        abort: {
                            httpStatus: 234,
                            percentage: 5.6,
                        },
                        delay: {
                            fixedDelay: {
                                seconds: "0",
                                nanos: 50000,
                            },
                            percentage: 7.8,
                        },
                    },
                    requestMirrorPolicy: {
                        backendService: home.id,
                    },
                    retryPolicy: {
                        numRetries: 4,
                        perTryTimeout: {
                            seconds: "30",
                        },
                        retryConditions: [
                            "5xx",
                            "deadline-exceeded",
                        ],
                    },
                    timeout: {
                        seconds: "20",
                        nanos: 750000000,
                    },
                    urlRewrite: {
                        hostRewrite: "dev.example.com",
                        pathPrefixRewrite: "/v1/api/",
                    },
                    weightedBackendServices: [{
                        backendService: home.id,
                        weight: 400,
                        headerAction: {
                            requestHeadersToRemoves: ["RemoveMe"],
                            requestHeadersToAdds: [{
                                headerName: "AddMe",
                                headerValue: "MyValue",
                                replace: true,
                            }],
                            responseHeadersToRemoves: ["RemoveMe"],
                            responseHeadersToAdds: [{
                                headerName: "AddMe",
                                headerValue: "MyValue",
                                replace: false,
                            }],
                        },
                    }],
                },
            }],
        }],
        tests: [{
            service: home.id,
            host: "hi.com",
            path: "/home",
        }],
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.compute.RegionHealthCheck("default",
        name="health-check",
        http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
            port=80,
        ))
    home = gcp.compute.RegionBackendService("home",
        name="home",
        protocol="HTTP",
        timeout_sec=10,
        health_checks=default.id,
        load_balancing_scheme="INTERNAL_MANAGED")
    regionurlmap = gcp.compute.RegionUrlMap("regionurlmap",
        name="regionurlmap",
        description="a description",
        default_service=home.id,
        host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
            hosts=["mysite.com"],
            path_matcher="allpaths",
        )],
        path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
            name="allpaths",
            default_service=home.id,
            path_rules=[gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
                paths=["/home"],
                route_action=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionArgs(
                    cors_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs(
                        allow_credentials=True,
                        allow_headers=["Allowed content"],
                        allow_methods=["GET"],
                        allow_origins=["Allowed origin"],
                        expose_headers=["Exposed header"],
                        max_age=30,
                        disabled=False,
                    ),
                    fault_injection_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs(
                        abort=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs(
                            http_status=234,
                            percentage=5.6,
                        ),
                        delay=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs(
                            fixed_delay=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs(
                                seconds="0",
                                nanos=50000,
                            ),
                            percentage=7.8,
                        ),
                    ),
                    request_mirror_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs(
                        backend_service=home.id,
                    ),
                    retry_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs(
                        num_retries=4,
                        per_try_timeout=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs(
                            seconds="30",
                        ),
                        retry_conditions=[
                            "5xx",
                            "deadline-exceeded",
                        ],
                    ),
                    timeout=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs(
                        seconds="20",
                        nanos=750000000,
                    ),
                    url_rewrite=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs(
                        host_rewrite="dev.example.com",
                        path_prefix_rewrite="/v1/api/",
                    ),
                    weighted_backend_services=[gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs(
                        backend_service=home.id,
                        weight=400,
                        header_action=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs(
                            request_headers_to_removes=["RemoveMe"],
                            request_headers_to_adds=[gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
                                header_name="AddMe",
                                header_value="MyValue",
                                replace=True,
                            )],
                            response_headers_to_removes=["RemoveMe"],
                            response_headers_to_adds=[gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
                                header_name="AddMe",
                                header_value="MyValue",
                                replace=False,
                            )],
                        ),
                    )],
                ),
            )],
        )],
        tests=[gcp.compute.RegionUrlMapTestArgs(
            service=home.id,
            host="hi.com",
            path="/home",
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
    			Name: pulumi.String("health-check"),
    			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
    				Port: pulumi.Int(80),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		home, err := compute.NewRegionBackendService(ctx, "home", &compute.RegionBackendServiceArgs{
    			Name:                pulumi.String("home"),
    			Protocol:            pulumi.String("HTTP"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        _default.ID(),
    			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionUrlMap(ctx, "regionurlmap", &compute.RegionUrlMapArgs{
    			Name:           pulumi.String("regionurlmap"),
    			Description:    pulumi.String("a description"),
    			DefaultService: home.ID(),
    			HostRules: compute.RegionUrlMapHostRuleArray{
    				&compute.RegionUrlMapHostRuleArgs{
    					Hosts: pulumi.StringArray{
    						pulumi.String("mysite.com"),
    					},
    					PathMatcher: pulumi.String("allpaths"),
    				},
    			},
    			PathMatchers: compute.RegionUrlMapPathMatcherArray{
    				&compute.RegionUrlMapPathMatcherArgs{
    					Name:           pulumi.String("allpaths"),
    					DefaultService: home.ID(),
    					PathRules: compute.RegionUrlMapPathMatcherPathRuleArray{
    						&compute.RegionUrlMapPathMatcherPathRuleArgs{
    							Paths: pulumi.StringArray{
    								pulumi.String("/home"),
    							},
    							RouteAction: &compute.RegionUrlMapPathMatcherPathRuleRouteActionArgs{
    								CorsPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs{
    									AllowCredentials: pulumi.Bool(true),
    									AllowHeaders: pulumi.StringArray{
    										pulumi.String("Allowed content"),
    									},
    									AllowMethods: pulumi.StringArray{
    										pulumi.String("GET"),
    									},
    									AllowOrigins: pulumi.StringArray{
    										pulumi.String("Allowed origin"),
    									},
    									ExposeHeaders: pulumi.StringArray{
    										pulumi.String("Exposed header"),
    									},
    									MaxAge:   pulumi.Int(30),
    									Disabled: pulumi.Bool(false),
    								},
    								FaultInjectionPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs{
    									Abort: &compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs{
    										HttpStatus: pulumi.Int(234),
    										Percentage: pulumi.Float64(5.6),
    									},
    									Delay: &compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs{
    										FixedDelay: &compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs{
    											Seconds: pulumi.String("0"),
    											Nanos:   pulumi.Int(50000),
    										},
    										Percentage: pulumi.Float64(7.8),
    									},
    								},
    								RequestMirrorPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs{
    									BackendService: home.ID(),
    								},
    								RetryPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs{
    									NumRetries: pulumi.Int(4),
    									PerTryTimeout: &compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs{
    										Seconds: pulumi.String("30"),
    									},
    									RetryConditions: pulumi.StringArray{
    										pulumi.String("5xx"),
    										pulumi.String("deadline-exceeded"),
    									},
    								},
    								Timeout: &compute.RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs{
    									Seconds: pulumi.String("20"),
    									Nanos:   pulumi.Int(750000000),
    								},
    								UrlRewrite: &compute.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs{
    									HostRewrite:       pulumi.String("dev.example.com"),
    									PathPrefixRewrite: pulumi.String("/v1/api/"),
    								},
    								WeightedBackendServices: compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArray{
    									&compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs{
    										BackendService: home.ID(),
    										Weight:         pulumi.Int(400),
    										HeaderAction: &compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs{
    											RequestHeadersToRemoves: pulumi.StringArray{
    												pulumi.String("RemoveMe"),
    											},
    											RequestHeadersToAdds: compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArray{
    												&compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs{
    													HeaderName:  pulumi.String("AddMe"),
    													HeaderValue: pulumi.String("MyValue"),
    													Replace:     pulumi.Bool(true),
    												},
    											},
    											ResponseHeadersToRemoves: pulumi.StringArray{
    												pulumi.String("RemoveMe"),
    											},
    											ResponseHeadersToAdds: compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArray{
    												&compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs{
    													HeaderName:  pulumi.String("AddMe"),
    													HeaderValue: pulumi.String("MyValue"),
    													Replace:     pulumi.Bool(false),
    												},
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			Tests: compute.RegionUrlMapTestArray{
    				&compute.RegionUrlMapTestArgs{
    					Service: home.ID(),
    					Host:    pulumi.String("hi.com"),
    					Path:    pulumi.String("/home"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var @default = new Gcp.Compute.RegionHealthCheck("default", new()
        {
            Name = "health-check",
            HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
            {
                Port = 80,
            },
        });
    
        var home = new Gcp.Compute.RegionBackendService("home", new()
        {
            Name = "home",
            Protocol = "HTTP",
            TimeoutSec = 10,
            HealthChecks = @default.Id,
            LoadBalancingScheme = "INTERNAL_MANAGED",
        });
    
        var regionurlmap = new Gcp.Compute.RegionUrlMap("regionurlmap", new()
        {
            Name = "regionurlmap",
            Description = "a description",
            DefaultService = home.Id,
            HostRules = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
                {
                    Hosts = new[]
                    {
                        "mysite.com",
                    },
                    PathMatcher = "allpaths",
                },
            },
            PathMatchers = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
                {
                    Name = "allpaths",
                    DefaultService = home.Id,
                    PathRules = new[]
                    {
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                        {
                            Paths = new[]
                            {
                                "/home",
                            },
                            RouteAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionArgs
                            {
                                CorsPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs
                                {
                                    AllowCredentials = true,
                                    AllowHeaders = new[]
                                    {
                                        "Allowed content",
                                    },
                                    AllowMethods = new[]
                                    {
                                        "GET",
                                    },
                                    AllowOrigins = new[]
                                    {
                                        "Allowed origin",
                                    },
                                    ExposeHeaders = new[]
                                    {
                                        "Exposed header",
                                    },
                                    MaxAge = 30,
                                    Disabled = false,
                                },
                                FaultInjectionPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs
                                {
                                    Abort = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs
                                    {
                                        HttpStatus = 234,
                                        Percentage = 5.6,
                                    },
                                    Delay = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs
                                    {
                                        FixedDelay = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs
                                        {
                                            Seconds = "0",
                                            Nanos = 50000,
                                        },
                                        Percentage = 7.8,
                                    },
                                },
                                RequestMirrorPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs
                                {
                                    BackendService = home.Id,
                                },
                                RetryPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs
                                {
                                    NumRetries = 4,
                                    PerTryTimeout = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs
                                    {
                                        Seconds = "30",
                                    },
                                    RetryConditions = new[]
                                    {
                                        "5xx",
                                        "deadline-exceeded",
                                    },
                                },
                                Timeout = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs
                                {
                                    Seconds = "20",
                                    Nanos = 750000000,
                                },
                                UrlRewrite = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs
                                {
                                    HostRewrite = "dev.example.com",
                                    PathPrefixRewrite = "/v1/api/",
                                },
                                WeightedBackendServices = new[]
                                {
                                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs
                                    {
                                        BackendService = home.Id,
                                        Weight = 400,
                                        HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs
                                        {
                                            RequestHeadersToRemoves = new[]
                                            {
                                                "RemoveMe",
                                            },
                                            RequestHeadersToAdds = new[]
                                            {
                                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs
                                                {
                                                    HeaderName = "AddMe",
                                                    HeaderValue = "MyValue",
                                                    Replace = true,
                                                },
                                            },
                                            ResponseHeadersToRemoves = new[]
                                            {
                                                "RemoveMe",
                                            },
                                            ResponseHeadersToAdds = new[]
                                            {
                                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs
                                                {
                                                    HeaderName = "AddMe",
                                                    HeaderValue = "MyValue",
                                                    Replace = false,
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            },
            Tests = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapTestArgs
                {
                    Service = home.Id,
                    Host = "hi.com",
                    Path = "/home",
                },
            },
        });
    
    });
    
    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.RegionUrlMap;
    import com.pulumi.gcp.compute.RegionUrlMapArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapTestArgs;
    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 default_ = new RegionHealthCheck("default", RegionHealthCheckArgs.builder()
                .name("health-check")
                .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                    .port(80)
                    .build())
                .build());
    
            var home = new RegionBackendService("home", RegionBackendServiceArgs.builder()
                .name("home")
                .protocol("HTTP")
                .timeoutSec(10)
                .healthChecks(default_.id())
                .loadBalancingScheme("INTERNAL_MANAGED")
                .build());
    
            var regionurlmap = new RegionUrlMap("regionurlmap", RegionUrlMapArgs.builder()
                .name("regionurlmap")
                .description("a description")
                .defaultService(home.id())
                .hostRules(RegionUrlMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("allpaths")
                    .build())
                .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                    .name("allpaths")
                    .defaultService(home.id())
                    .pathRules(RegionUrlMapPathMatcherPathRuleArgs.builder()
                        .paths("/home")
                        .routeAction(RegionUrlMapPathMatcherPathRuleRouteActionArgs.builder()
                            .corsPolicy(RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs.builder()
                                .allowCredentials(true)
                                .allowHeaders("Allowed content")
                                .allowMethods("GET")
                                .allowOrigins("Allowed origin")
                                .exposeHeaders("Exposed header")
                                .maxAge(30)
                                .disabled(false)
                                .build())
                            .faultInjectionPolicy(RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs.builder()
                                .abort(RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs.builder()
                                    .httpStatus(234)
                                    .percentage(5.6)
                                    .build())
                                .delay(RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs.builder()
                                    .fixedDelay(RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs.builder()
                                        .seconds(0)
                                        .nanos(50000)
                                        .build())
                                    .percentage(7.8)
                                    .build())
                                .build())
                            .requestMirrorPolicy(RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs.builder()
                                .backendService(home.id())
                                .build())
                            .retryPolicy(RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs.builder()
                                .numRetries(4)
                                .perTryTimeout(RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs.builder()
                                    .seconds(30)
                                    .build())
                                .retryConditions(                            
                                    "5xx",
                                    "deadline-exceeded")
                                .build())
                            .timeout(RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs.builder()
                                .seconds(20)
                                .nanos(750000000)
                                .build())
                            .urlRewrite(RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs.builder()
                                .hostRewrite("dev.example.com")
                                .pathPrefixRewrite("/v1/api/")
                                .build())
                            .weightedBackendServices(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs.builder()
                                .backendService(home.id())
                                .weight(400)
                                .headerAction(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                                    .requestHeadersToRemoves("RemoveMe")
                                    .requestHeadersToAdds(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                                        .headerName("AddMe")
                                        .headerValue("MyValue")
                                        .replace(true)
                                        .build())
                                    .responseHeadersToRemoves("RemoveMe")
                                    .responseHeadersToAdds(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                        .headerName("AddMe")
                                        .headerValue("MyValue")
                                        .replace(false)
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .tests(RegionUrlMapTestArgs.builder()
                    .service(home.id())
                    .host("hi.com")
                    .path("/home")
                    .build())
                .build());
    
        }
    }
    
    resources:
      regionurlmap:
        type: gcp:compute:RegionUrlMap
        properties:
          name: regionurlmap
          description: a description
          defaultService: ${home.id}
          hostRules:
            - hosts:
                - mysite.com
              pathMatcher: allpaths
          pathMatchers:
            - name: allpaths
              defaultService: ${home.id}
              pathRules:
                - paths:
                    - /home
                  routeAction:
                    corsPolicy:
                      allowCredentials: true
                      allowHeaders:
                        - Allowed content
                      allowMethods:
                        - GET
                      allowOrigins:
                        - Allowed origin
                      exposeHeaders:
                        - Exposed header
                      maxAge: 30
                      disabled: false
                    faultInjectionPolicy:
                      abort:
                        httpStatus: 234
                        percentage: 5.6
                      delay:
                        fixedDelay:
                          seconds: 0
                          nanos: 50000
                        percentage: 7.8
                    requestMirrorPolicy:
                      backendService: ${home.id}
                    retryPolicy:
                      numRetries: 4
                      perTryTimeout:
                        seconds: 30
                      retryConditions:
                        - 5xx
                        - deadline-exceeded
                    timeout:
                      seconds: 20
                      nanos: 7.5e+08
                    urlRewrite:
                      hostRewrite: dev.example.com
                      pathPrefixRewrite: /v1/api/
                    weightedBackendServices:
                      - backendService: ${home.id}
                        weight: 400
                        headerAction:
                          requestHeadersToRemoves:
                            - RemoveMe
                          requestHeadersToAdds:
                            - headerName: AddMe
                              headerValue: MyValue
                              replace: true
                          responseHeadersToRemoves:
                            - RemoveMe
                          responseHeadersToAdds:
                            - headerName: AddMe
                              headerValue: MyValue
                              replace: false
          tests:
            - service: ${home.id}
              host: hi.com
              path: /home
      home:
        type: gcp:compute:RegionBackendService
        properties:
          name: home
          protocol: HTTP
          timeoutSec: 10
          healthChecks: ${default.id}
          loadBalancingScheme: INTERNAL_MANAGED
      default:
        type: gcp:compute:RegionHealthCheck
        properties:
          name: health-check
          httpHealthCheck:
            port: 80
    

    Region Url Map L7 Ilb Path Partial

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.compute.RegionHealthCheck("default", {
        name: "health-check",
        httpHealthCheck: {
            port: 80,
        },
    });
    const home = new gcp.compute.RegionBackendService("home", {
        name: "home",
        protocol: "HTTP",
        timeoutSec: 10,
        healthChecks: _default.id,
        loadBalancingScheme: "INTERNAL_MANAGED",
    });
    const regionurlmap = new gcp.compute.RegionUrlMap("regionurlmap", {
        name: "regionurlmap",
        description: "a description",
        defaultService: home.id,
        hostRules: [{
            hosts: ["mysite.com"],
            pathMatcher: "allpaths",
        }],
        pathMatchers: [{
            name: "allpaths",
            defaultService: home.id,
            pathRules: [{
                paths: ["/home"],
                routeAction: {
                    retryPolicy: {
                        numRetries: 4,
                        perTryTimeout: {
                            seconds: "30",
                        },
                        retryConditions: [
                            "5xx",
                            "deadline-exceeded",
                        ],
                    },
                    timeout: {
                        seconds: "20",
                        nanos: 750000000,
                    },
                    urlRewrite: {
                        hostRewrite: "dev.example.com",
                        pathPrefixRewrite: "/v1/api/",
                    },
                    weightedBackendServices: [{
                        backendService: home.id,
                        weight: 400,
                        headerAction: {
                            responseHeadersToAdds: [{
                                headerName: "AddMe",
                                headerValue: "MyValue",
                                replace: false,
                            }],
                        },
                    }],
                },
            }],
        }],
        tests: [{
            service: home.id,
            host: "hi.com",
            path: "/home",
        }],
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.compute.RegionHealthCheck("default",
        name="health-check",
        http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
            port=80,
        ))
    home = gcp.compute.RegionBackendService("home",
        name="home",
        protocol="HTTP",
        timeout_sec=10,
        health_checks=default.id,
        load_balancing_scheme="INTERNAL_MANAGED")
    regionurlmap = gcp.compute.RegionUrlMap("regionurlmap",
        name="regionurlmap",
        description="a description",
        default_service=home.id,
        host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
            hosts=["mysite.com"],
            path_matcher="allpaths",
        )],
        path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
            name="allpaths",
            default_service=home.id,
            path_rules=[gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
                paths=["/home"],
                route_action=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionArgs(
                    retry_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs(
                        num_retries=4,
                        per_try_timeout=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs(
                            seconds="30",
                        ),
                        retry_conditions=[
                            "5xx",
                            "deadline-exceeded",
                        ],
                    ),
                    timeout=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs(
                        seconds="20",
                        nanos=750000000,
                    ),
                    url_rewrite=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs(
                        host_rewrite="dev.example.com",
                        path_prefix_rewrite="/v1/api/",
                    ),
                    weighted_backend_services=[gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs(
                        backend_service=home.id,
                        weight=400,
                        header_action=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs(
                            response_headers_to_adds=[gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
                                header_name="AddMe",
                                header_value="MyValue",
                                replace=False,
                            )],
                        ),
                    )],
                ),
            )],
        )],
        tests=[gcp.compute.RegionUrlMapTestArgs(
            service=home.id,
            host="hi.com",
            path="/home",
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
    			Name: pulumi.String("health-check"),
    			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
    				Port: pulumi.Int(80),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		home, err := compute.NewRegionBackendService(ctx, "home", &compute.RegionBackendServiceArgs{
    			Name:                pulumi.String("home"),
    			Protocol:            pulumi.String("HTTP"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        _default.ID(),
    			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionUrlMap(ctx, "regionurlmap", &compute.RegionUrlMapArgs{
    			Name:           pulumi.String("regionurlmap"),
    			Description:    pulumi.String("a description"),
    			DefaultService: home.ID(),
    			HostRules: compute.RegionUrlMapHostRuleArray{
    				&compute.RegionUrlMapHostRuleArgs{
    					Hosts: pulumi.StringArray{
    						pulumi.String("mysite.com"),
    					},
    					PathMatcher: pulumi.String("allpaths"),
    				},
    			},
    			PathMatchers: compute.RegionUrlMapPathMatcherArray{
    				&compute.RegionUrlMapPathMatcherArgs{
    					Name:           pulumi.String("allpaths"),
    					DefaultService: home.ID(),
    					PathRules: compute.RegionUrlMapPathMatcherPathRuleArray{
    						&compute.RegionUrlMapPathMatcherPathRuleArgs{
    							Paths: pulumi.StringArray{
    								pulumi.String("/home"),
    							},
    							RouteAction: &compute.RegionUrlMapPathMatcherPathRuleRouteActionArgs{
    								RetryPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs{
    									NumRetries: pulumi.Int(4),
    									PerTryTimeout: &compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs{
    										Seconds: pulumi.String("30"),
    									},
    									RetryConditions: pulumi.StringArray{
    										pulumi.String("5xx"),
    										pulumi.String("deadline-exceeded"),
    									},
    								},
    								Timeout: &compute.RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs{
    									Seconds: pulumi.String("20"),
    									Nanos:   pulumi.Int(750000000),
    								},
    								UrlRewrite: &compute.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs{
    									HostRewrite:       pulumi.String("dev.example.com"),
    									PathPrefixRewrite: pulumi.String("/v1/api/"),
    								},
    								WeightedBackendServices: compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArray{
    									&compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs{
    										BackendService: home.ID(),
    										Weight:         pulumi.Int(400),
    										HeaderAction: &compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs{
    											ResponseHeadersToAdds: compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArray{
    												&compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs{
    													HeaderName:  pulumi.String("AddMe"),
    													HeaderValue: pulumi.String("MyValue"),
    													Replace:     pulumi.Bool(false),
    												},
    											},
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			Tests: compute.RegionUrlMapTestArray{
    				&compute.RegionUrlMapTestArgs{
    					Service: home.ID(),
    					Host:    pulumi.String("hi.com"),
    					Path:    pulumi.String("/home"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var @default = new Gcp.Compute.RegionHealthCheck("default", new()
        {
            Name = "health-check",
            HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
            {
                Port = 80,
            },
        });
    
        var home = new Gcp.Compute.RegionBackendService("home", new()
        {
            Name = "home",
            Protocol = "HTTP",
            TimeoutSec = 10,
            HealthChecks = @default.Id,
            LoadBalancingScheme = "INTERNAL_MANAGED",
        });
    
        var regionurlmap = new Gcp.Compute.RegionUrlMap("regionurlmap", new()
        {
            Name = "regionurlmap",
            Description = "a description",
            DefaultService = home.Id,
            HostRules = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
                {
                    Hosts = new[]
                    {
                        "mysite.com",
                    },
                    PathMatcher = "allpaths",
                },
            },
            PathMatchers = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
                {
                    Name = "allpaths",
                    DefaultService = home.Id,
                    PathRules = new[]
                    {
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                        {
                            Paths = new[]
                            {
                                "/home",
                            },
                            RouteAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionArgs
                            {
                                RetryPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs
                                {
                                    NumRetries = 4,
                                    PerTryTimeout = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs
                                    {
                                        Seconds = "30",
                                    },
                                    RetryConditions = new[]
                                    {
                                        "5xx",
                                        "deadline-exceeded",
                                    },
                                },
                                Timeout = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs
                                {
                                    Seconds = "20",
                                    Nanos = 750000000,
                                },
                                UrlRewrite = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs
                                {
                                    HostRewrite = "dev.example.com",
                                    PathPrefixRewrite = "/v1/api/",
                                },
                                WeightedBackendServices = new[]
                                {
                                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs
                                    {
                                        BackendService = home.Id,
                                        Weight = 400,
                                        HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs
                                        {
                                            ResponseHeadersToAdds = new[]
                                            {
                                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs
                                                {
                                                    HeaderName = "AddMe",
                                                    HeaderValue = "MyValue",
                                                    Replace = false,
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            },
            Tests = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapTestArgs
                {
                    Service = home.Id,
                    Host = "hi.com",
                    Path = "/home",
                },
            },
        });
    
    });
    
    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.RegionUrlMap;
    import com.pulumi.gcp.compute.RegionUrlMapArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapTestArgs;
    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 default_ = new RegionHealthCheck("default", RegionHealthCheckArgs.builder()
                .name("health-check")
                .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                    .port(80)
                    .build())
                .build());
    
            var home = new RegionBackendService("home", RegionBackendServiceArgs.builder()
                .name("home")
                .protocol("HTTP")
                .timeoutSec(10)
                .healthChecks(default_.id())
                .loadBalancingScheme("INTERNAL_MANAGED")
                .build());
    
            var regionurlmap = new RegionUrlMap("regionurlmap", RegionUrlMapArgs.builder()
                .name("regionurlmap")
                .description("a description")
                .defaultService(home.id())
                .hostRules(RegionUrlMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("allpaths")
                    .build())
                .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                    .name("allpaths")
                    .defaultService(home.id())
                    .pathRules(RegionUrlMapPathMatcherPathRuleArgs.builder()
                        .paths("/home")
                        .routeAction(RegionUrlMapPathMatcherPathRuleRouteActionArgs.builder()
                            .retryPolicy(RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs.builder()
                                .numRetries(4)
                                .perTryTimeout(RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs.builder()
                                    .seconds(30)
                                    .build())
                                .retryConditions(                            
                                    "5xx",
                                    "deadline-exceeded")
                                .build())
                            .timeout(RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs.builder()
                                .seconds(20)
                                .nanos(750000000)
                                .build())
                            .urlRewrite(RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs.builder()
                                .hostRewrite("dev.example.com")
                                .pathPrefixRewrite("/v1/api/")
                                .build())
                            .weightedBackendServices(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs.builder()
                                .backendService(home.id())
                                .weight(400)
                                .headerAction(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                                    .responseHeadersToAdds(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                        .headerName("AddMe")
                                        .headerValue("MyValue")
                                        .replace(false)
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .tests(RegionUrlMapTestArgs.builder()
                    .service(home.id())
                    .host("hi.com")
                    .path("/home")
                    .build())
                .build());
    
        }
    }
    
    resources:
      regionurlmap:
        type: gcp:compute:RegionUrlMap
        properties:
          name: regionurlmap
          description: a description
          defaultService: ${home.id}
          hostRules:
            - hosts:
                - mysite.com
              pathMatcher: allpaths
          pathMatchers:
            - name: allpaths
              defaultService: ${home.id}
              pathRules:
                - paths:
                    - /home
                  routeAction:
                    retryPolicy:
                      numRetries: 4
                      perTryTimeout:
                        seconds: 30
                      retryConditions:
                        - 5xx
                        - deadline-exceeded
                    timeout:
                      seconds: 20
                      nanos: 7.5e+08
                    urlRewrite:
                      hostRewrite: dev.example.com
                      pathPrefixRewrite: /v1/api/
                    weightedBackendServices:
                      - backendService: ${home.id}
                        weight: 400
                        headerAction:
                          responseHeadersToAdds:
                            - headerName: AddMe
                              headerValue: MyValue
                              replace: false
          tests:
            - service: ${home.id}
              host: hi.com
              path: /home
      home:
        type: gcp:compute:RegionBackendService
        properties:
          name: home
          protocol: HTTP
          timeoutSec: 10
          healthChecks: ${default.id}
          loadBalancingScheme: INTERNAL_MANAGED
      default:
        type: gcp:compute:RegionHealthCheck
        properties:
          name: health-check
          httpHealthCheck:
            port: 80
    

    Region Url Map L7 Ilb Route

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.compute.RegionHealthCheck("default", {
        name: "health-check",
        httpHealthCheck: {
            port: 80,
        },
    });
    const home = new gcp.compute.RegionBackendService("home", {
        name: "home",
        protocol: "HTTP",
        timeoutSec: 10,
        healthChecks: _default.id,
        loadBalancingScheme: "INTERNAL_MANAGED",
    });
    const regionurlmap = new gcp.compute.RegionUrlMap("regionurlmap", {
        name: "regionurlmap",
        description: "a description",
        defaultService: home.id,
        hostRules: [{
            hosts: ["mysite.com"],
            pathMatcher: "allpaths",
        }],
        pathMatchers: [{
            name: "allpaths",
            defaultService: home.id,
            routeRules: [{
                priority: 1,
                headerAction: {
                    requestHeadersToRemoves: ["RemoveMe2"],
                    requestHeadersToAdds: [{
                        headerName: "AddSomethingElse",
                        headerValue: "MyOtherValue",
                        replace: true,
                    }],
                    responseHeadersToRemoves: ["RemoveMe3"],
                    responseHeadersToAdds: [{
                        headerName: "AddMe",
                        headerValue: "MyValue",
                        replace: false,
                    }],
                },
                matchRules: [{
                    fullPathMatch: "a full path",
                    headerMatches: [{
                        headerName: "someheader",
                        exactMatch: "match this exactly",
                        invertMatch: true,
                    }],
                    ignoreCase: true,
                    metadataFilters: [{
                        filterMatchCriteria: "MATCH_ANY",
                        filterLabels: [{
                            name: "PLANET",
                            value: "MARS",
                        }],
                    }],
                    queryParameterMatches: [{
                        name: "a query parameter",
                        presentMatch: true,
                    }],
                }],
                urlRedirect: {
                    hostRedirect: "A host",
                    httpsRedirect: false,
                    pathRedirect: "some/path",
                    redirectResponseCode: "TEMPORARY_REDIRECT",
                    stripQuery: true,
                },
            }],
        }],
        tests: [{
            service: home.id,
            host: "hi.com",
            path: "/home",
        }],
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.compute.RegionHealthCheck("default",
        name="health-check",
        http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
            port=80,
        ))
    home = gcp.compute.RegionBackendService("home",
        name="home",
        protocol="HTTP",
        timeout_sec=10,
        health_checks=default.id,
        load_balancing_scheme="INTERNAL_MANAGED")
    regionurlmap = gcp.compute.RegionUrlMap("regionurlmap",
        name="regionurlmap",
        description="a description",
        default_service=home.id,
        host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
            hosts=["mysite.com"],
            path_matcher="allpaths",
        )],
        path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
            name="allpaths",
            default_service=home.id,
            route_rules=[gcp.compute.RegionUrlMapPathMatcherRouteRuleArgs(
                priority=1,
                header_action=gcp.compute.RegionUrlMapPathMatcherRouteRuleHeaderActionArgs(
                    request_headers_to_removes=["RemoveMe2"],
                    request_headers_to_adds=[gcp.compute.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs(
                        header_name="AddSomethingElse",
                        header_value="MyOtherValue",
                        replace=True,
                    )],
                    response_headers_to_removes=["RemoveMe3"],
                    response_headers_to_adds=[gcp.compute.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs(
                        header_name="AddMe",
                        header_value="MyValue",
                        replace=False,
                    )],
                ),
                match_rules=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs(
                    full_path_match="a full path",
                    header_matches=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
                        header_name="someheader",
                        exact_match="match this exactly",
                        invert_match=True,
                    )],
                    ignore_case=True,
                    metadata_filters=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs(
                        filter_match_criteria="MATCH_ANY",
                        filter_labels=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs(
                            name="PLANET",
                            value="MARS",
                        )],
                    )],
                    query_parameter_matches=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
                        name="a query parameter",
                        present_match=True,
                    )],
                )],
                url_redirect=gcp.compute.RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs(
                    host_redirect="A host",
                    https_redirect=False,
                    path_redirect="some/path",
                    redirect_response_code="TEMPORARY_REDIRECT",
                    strip_query=True,
                ),
            )],
        )],
        tests=[gcp.compute.RegionUrlMapTestArgs(
            service=home.id,
            host="hi.com",
            path="/home",
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
    			Name: pulumi.String("health-check"),
    			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
    				Port: pulumi.Int(80),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		home, err := compute.NewRegionBackendService(ctx, "home", &compute.RegionBackendServiceArgs{
    			Name:                pulumi.String("home"),
    			Protocol:            pulumi.String("HTTP"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        _default.ID(),
    			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionUrlMap(ctx, "regionurlmap", &compute.RegionUrlMapArgs{
    			Name:           pulumi.String("regionurlmap"),
    			Description:    pulumi.String("a description"),
    			DefaultService: home.ID(),
    			HostRules: compute.RegionUrlMapHostRuleArray{
    				&compute.RegionUrlMapHostRuleArgs{
    					Hosts: pulumi.StringArray{
    						pulumi.String("mysite.com"),
    					},
    					PathMatcher: pulumi.String("allpaths"),
    				},
    			},
    			PathMatchers: compute.RegionUrlMapPathMatcherArray{
    				&compute.RegionUrlMapPathMatcherArgs{
    					Name:           pulumi.String("allpaths"),
    					DefaultService: home.ID(),
    					RouteRules: compute.RegionUrlMapPathMatcherRouteRuleArray{
    						&compute.RegionUrlMapPathMatcherRouteRuleArgs{
    							Priority: pulumi.Int(1),
    							HeaderAction: &compute.RegionUrlMapPathMatcherRouteRuleHeaderActionArgs{
    								RequestHeadersToRemoves: pulumi.StringArray{
    									pulumi.String("RemoveMe2"),
    								},
    								RequestHeadersToAdds: compute.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArray{
    									&compute.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs{
    										HeaderName:  pulumi.String("AddSomethingElse"),
    										HeaderValue: pulumi.String("MyOtherValue"),
    										Replace:     pulumi.Bool(true),
    									},
    								},
    								ResponseHeadersToRemoves: pulumi.StringArray{
    									pulumi.String("RemoveMe3"),
    								},
    								ResponseHeadersToAdds: compute.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArray{
    									&compute.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs{
    										HeaderName:  pulumi.String("AddMe"),
    										HeaderValue: pulumi.String("MyValue"),
    										Replace:     pulumi.Bool(false),
    									},
    								},
    							},
    							MatchRules: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArray{
    								&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs{
    									FullPathMatch: pulumi.String("a full path"),
    									HeaderMatches: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArray{
    										&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs{
    											HeaderName:  pulumi.String("someheader"),
    											ExactMatch:  pulumi.String("match this exactly"),
    											InvertMatch: pulumi.Bool(true),
    										},
    									},
    									IgnoreCase: pulumi.Bool(true),
    									MetadataFilters: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArray{
    										&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs{
    											FilterMatchCriteria: pulumi.String("MATCH_ANY"),
    											FilterLabels: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArray{
    												&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs{
    													Name:  pulumi.String("PLANET"),
    													Value: pulumi.String("MARS"),
    												},
    											},
    										},
    									},
    									QueryParameterMatches: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArray{
    										&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs{
    											Name:         pulumi.String("a query parameter"),
    											PresentMatch: pulumi.Bool(true),
    										},
    									},
    								},
    							},
    							UrlRedirect: &compute.RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs{
    								HostRedirect:         pulumi.String("A host"),
    								HttpsRedirect:        pulumi.Bool(false),
    								PathRedirect:         pulumi.String("some/path"),
    								RedirectResponseCode: pulumi.String("TEMPORARY_REDIRECT"),
    								StripQuery:           pulumi.Bool(true),
    							},
    						},
    					},
    				},
    			},
    			Tests: compute.RegionUrlMapTestArray{
    				&compute.RegionUrlMapTestArgs{
    					Service: home.ID(),
    					Host:    pulumi.String("hi.com"),
    					Path:    pulumi.String("/home"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var @default = new Gcp.Compute.RegionHealthCheck("default", new()
        {
            Name = "health-check",
            HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
            {
                Port = 80,
            },
        });
    
        var home = new Gcp.Compute.RegionBackendService("home", new()
        {
            Name = "home",
            Protocol = "HTTP",
            TimeoutSec = 10,
            HealthChecks = @default.Id,
            LoadBalancingScheme = "INTERNAL_MANAGED",
        });
    
        var regionurlmap = new Gcp.Compute.RegionUrlMap("regionurlmap", new()
        {
            Name = "regionurlmap",
            Description = "a description",
            DefaultService = home.Id,
            HostRules = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
                {
                    Hosts = new[]
                    {
                        "mysite.com",
                    },
                    PathMatcher = "allpaths",
                },
            },
            PathMatchers = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
                {
                    Name = "allpaths",
                    DefaultService = home.Id,
                    RouteRules = new[]
                    {
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleArgs
                        {
                            Priority = 1,
                            HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleHeaderActionArgs
                            {
                                RequestHeadersToRemoves = new[]
                                {
                                    "RemoveMe2",
                                },
                                RequestHeadersToAdds = new[]
                                {
                                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs
                                    {
                                        HeaderName = "AddSomethingElse",
                                        HeaderValue = "MyOtherValue",
                                        Replace = true,
                                    },
                                },
                                ResponseHeadersToRemoves = new[]
                                {
                                    "RemoveMe3",
                                },
                                ResponseHeadersToAdds = new[]
                                {
                                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs
                                    {
                                        HeaderName = "AddMe",
                                        HeaderValue = "MyValue",
                                        Replace = false,
                                    },
                                },
                            },
                            MatchRules = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs
                                {
                                    FullPathMatch = "a full path",
                                    HeaderMatches = new[]
                                    {
                                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs
                                        {
                                            HeaderName = "someheader",
                                            ExactMatch = "match this exactly",
                                            InvertMatch = true,
                                        },
                                    },
                                    IgnoreCase = true,
                                    MetadataFilters = new[]
                                    {
                                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs
                                        {
                                            FilterMatchCriteria = "MATCH_ANY",
                                            FilterLabels = new[]
                                            {
                                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs
                                                {
                                                    Name = "PLANET",
                                                    Value = "MARS",
                                                },
                                            },
                                        },
                                    },
                                    QueryParameterMatches = new[]
                                    {
                                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs
                                        {
                                            Name = "a query parameter",
                                            PresentMatch = true,
                                        },
                                    },
                                },
                            },
                            UrlRedirect = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs
                            {
                                HostRedirect = "A host",
                                HttpsRedirect = false,
                                PathRedirect = "some/path",
                                RedirectResponseCode = "TEMPORARY_REDIRECT",
                                StripQuery = true,
                            },
                        },
                    },
                },
            },
            Tests = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapTestArgs
                {
                    Service = home.Id,
                    Host = "hi.com",
                    Path = "/home",
                },
            },
        });
    
    });
    
    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.RegionUrlMap;
    import com.pulumi.gcp.compute.RegionUrlMapArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapTestArgs;
    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 default_ = new RegionHealthCheck("default", RegionHealthCheckArgs.builder()
                .name("health-check")
                .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                    .port(80)
                    .build())
                .build());
    
            var home = new RegionBackendService("home", RegionBackendServiceArgs.builder()
                .name("home")
                .protocol("HTTP")
                .timeoutSec(10)
                .healthChecks(default_.id())
                .loadBalancingScheme("INTERNAL_MANAGED")
                .build());
    
            var regionurlmap = new RegionUrlMap("regionurlmap", RegionUrlMapArgs.builder()
                .name("regionurlmap")
                .description("a description")
                .defaultService(home.id())
                .hostRules(RegionUrlMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("allpaths")
                    .build())
                .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                    .name("allpaths")
                    .defaultService(home.id())
                    .routeRules(RegionUrlMapPathMatcherRouteRuleArgs.builder()
                        .priority(1)
                        .headerAction(RegionUrlMapPathMatcherRouteRuleHeaderActionArgs.builder()
                            .requestHeadersToRemoves("RemoveMe2")
                            .requestHeadersToAdds(RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs.builder()
                                .headerName("AddSomethingElse")
                                .headerValue("MyOtherValue")
                                .replace(true)
                                .build())
                            .responseHeadersToRemoves("RemoveMe3")
                            .responseHeadersToAdds(RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs.builder()
                                .headerName("AddMe")
                                .headerValue("MyValue")
                                .replace(false)
                                .build())
                            .build())
                        .matchRules(RegionUrlMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .fullPathMatch("a full path")
                            .headerMatches(RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs.builder()
                                .headerName("someheader")
                                .exactMatch("match this exactly")
                                .invertMatch(true)
                                .build())
                            .ignoreCase(true)
                            .metadataFilters(RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs.builder()
                                .filterMatchCriteria("MATCH_ANY")
                                .filterLabels(RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs.builder()
                                    .name("PLANET")
                                    .value("MARS")
                                    .build())
                                .build())
                            .queryParameterMatches(RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                                .name("a query parameter")
                                .presentMatch(true)
                                .build())
                            .build())
                        .urlRedirect(RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs.builder()
                            .hostRedirect("A host")
                            .httpsRedirect(false)
                            .pathRedirect("some/path")
                            .redirectResponseCode("TEMPORARY_REDIRECT")
                            .stripQuery(true)
                            .build())
                        .build())
                    .build())
                .tests(RegionUrlMapTestArgs.builder()
                    .service(home.id())
                    .host("hi.com")
                    .path("/home")
                    .build())
                .build());
    
        }
    }
    
    resources:
      regionurlmap:
        type: gcp:compute:RegionUrlMap
        properties:
          name: regionurlmap
          description: a description
          defaultService: ${home.id}
          hostRules:
            - hosts:
                - mysite.com
              pathMatcher: allpaths
          pathMatchers:
            - name: allpaths
              defaultService: ${home.id}
              routeRules:
                - priority: 1
                  headerAction:
                    requestHeadersToRemoves:
                      - RemoveMe2
                    requestHeadersToAdds:
                      - headerName: AddSomethingElse
                        headerValue: MyOtherValue
                        replace: true
                    responseHeadersToRemoves:
                      - RemoveMe3
                    responseHeadersToAdds:
                      - headerName: AddMe
                        headerValue: MyValue
                        replace: false
                  matchRules:
                    - fullPathMatch: a full path
                      headerMatches:
                        - headerName: someheader
                          exactMatch: match this exactly
                          invertMatch: true
                      ignoreCase: true
                      metadataFilters:
                        - filterMatchCriteria: MATCH_ANY
                          filterLabels:
                            - name: PLANET
                              value: MARS
                      queryParameterMatches:
                        - name: a query parameter
                          presentMatch: true
                  urlRedirect:
                    hostRedirect: A host
                    httpsRedirect: false
                    pathRedirect: some/path
                    redirectResponseCode: TEMPORARY_REDIRECT
                    stripQuery: true
          tests:
            - service: ${home.id}
              host: hi.com
              path: /home
      home:
        type: gcp:compute:RegionBackendService
        properties:
          name: home
          protocol: HTTP
          timeoutSec: 10
          healthChecks: ${default.id}
          loadBalancingScheme: INTERNAL_MANAGED
      default:
        type: gcp:compute:RegionHealthCheck
        properties:
          name: health-check
          httpHealthCheck:
            port: 80
    

    Region Url Map L7 Ilb Route Partial

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.compute.RegionHealthCheck("default", {
        name: "health-check",
        httpHealthCheck: {
            port: 80,
        },
    });
    const home = new gcp.compute.RegionBackendService("home", {
        name: "home",
        protocol: "HTTP",
        timeoutSec: 10,
        healthChecks: _default.id,
        loadBalancingScheme: "INTERNAL_MANAGED",
    });
    const regionurlmap = new gcp.compute.RegionUrlMap("regionurlmap", {
        name: "regionurlmap",
        description: "a description",
        defaultService: home.id,
        hostRules: [{
            hosts: ["mysite.com"],
            pathMatcher: "allpaths",
        }],
        pathMatchers: [{
            name: "allpaths",
            defaultService: home.id,
            routeRules: [{
                priority: 1,
                service: home.id,
                headerAction: {
                    requestHeadersToRemoves: ["RemoveMe2"],
                },
                matchRules: [{
                    fullPathMatch: "a full path",
                    headerMatches: [{
                        headerName: "someheader",
                        exactMatch: "match this exactly",
                        invertMatch: true,
                    }],
                    queryParameterMatches: [{
                        name: "a query parameter",
                        presentMatch: true,
                    }],
                }],
            }],
        }],
        tests: [{
            service: home.id,
            host: "hi.com",
            path: "/home",
        }],
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.compute.RegionHealthCheck("default",
        name="health-check",
        http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
            port=80,
        ))
    home = gcp.compute.RegionBackendService("home",
        name="home",
        protocol="HTTP",
        timeout_sec=10,
        health_checks=default.id,
        load_balancing_scheme="INTERNAL_MANAGED")
    regionurlmap = gcp.compute.RegionUrlMap("regionurlmap",
        name="regionurlmap",
        description="a description",
        default_service=home.id,
        host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
            hosts=["mysite.com"],
            path_matcher="allpaths",
        )],
        path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
            name="allpaths",
            default_service=home.id,
            route_rules=[gcp.compute.RegionUrlMapPathMatcherRouteRuleArgs(
                priority=1,
                service=home.id,
                header_action=gcp.compute.RegionUrlMapPathMatcherRouteRuleHeaderActionArgs(
                    request_headers_to_removes=["RemoveMe2"],
                ),
                match_rules=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs(
                    full_path_match="a full path",
                    header_matches=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs(
                        header_name="someheader",
                        exact_match="match this exactly",
                        invert_match=True,
                    )],
                    query_parameter_matches=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs(
                        name="a query parameter",
                        present_match=True,
                    )],
                )],
            )],
        )],
        tests=[gcp.compute.RegionUrlMapTestArgs(
            service=home.id,
            host="hi.com",
            path="/home",
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
    			Name: pulumi.String("health-check"),
    			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
    				Port: pulumi.Int(80),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		home, err := compute.NewRegionBackendService(ctx, "home", &compute.RegionBackendServiceArgs{
    			Name:                pulumi.String("home"),
    			Protocol:            pulumi.String("HTTP"),
    			TimeoutSec:          pulumi.Int(10),
    			HealthChecks:        _default.ID(),
    			LoadBalancingScheme: pulumi.String("INTERNAL_MANAGED"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionUrlMap(ctx, "regionurlmap", &compute.RegionUrlMapArgs{
    			Name:           pulumi.String("regionurlmap"),
    			Description:    pulumi.String("a description"),
    			DefaultService: home.ID(),
    			HostRules: compute.RegionUrlMapHostRuleArray{
    				&compute.RegionUrlMapHostRuleArgs{
    					Hosts: pulumi.StringArray{
    						pulumi.String("mysite.com"),
    					},
    					PathMatcher: pulumi.String("allpaths"),
    				},
    			},
    			PathMatchers: compute.RegionUrlMapPathMatcherArray{
    				&compute.RegionUrlMapPathMatcherArgs{
    					Name:           pulumi.String("allpaths"),
    					DefaultService: home.ID(),
    					RouteRules: compute.RegionUrlMapPathMatcherRouteRuleArray{
    						&compute.RegionUrlMapPathMatcherRouteRuleArgs{
    							Priority: pulumi.Int(1),
    							Service:  home.ID(),
    							HeaderAction: &compute.RegionUrlMapPathMatcherRouteRuleHeaderActionArgs{
    								RequestHeadersToRemoves: pulumi.StringArray{
    									pulumi.String("RemoveMe2"),
    								},
    							},
    							MatchRules: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArray{
    								&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs{
    									FullPathMatch: pulumi.String("a full path"),
    									HeaderMatches: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArray{
    										&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs{
    											HeaderName:  pulumi.String("someheader"),
    											ExactMatch:  pulumi.String("match this exactly"),
    											InvertMatch: pulumi.Bool(true),
    										},
    									},
    									QueryParameterMatches: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArray{
    										&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs{
    											Name:         pulumi.String("a query parameter"),
    											PresentMatch: pulumi.Bool(true),
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			Tests: compute.RegionUrlMapTestArray{
    				&compute.RegionUrlMapTestArgs{
    					Service: home.ID(),
    					Host:    pulumi.String("hi.com"),
    					Path:    pulumi.String("/home"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var @default = new Gcp.Compute.RegionHealthCheck("default", new()
        {
            Name = "health-check",
            HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
            {
                Port = 80,
            },
        });
    
        var home = new Gcp.Compute.RegionBackendService("home", new()
        {
            Name = "home",
            Protocol = "HTTP",
            TimeoutSec = 10,
            HealthChecks = @default.Id,
            LoadBalancingScheme = "INTERNAL_MANAGED",
        });
    
        var regionurlmap = new Gcp.Compute.RegionUrlMap("regionurlmap", new()
        {
            Name = "regionurlmap",
            Description = "a description",
            DefaultService = home.Id,
            HostRules = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
                {
                    Hosts = new[]
                    {
                        "mysite.com",
                    },
                    PathMatcher = "allpaths",
                },
            },
            PathMatchers = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
                {
                    Name = "allpaths",
                    DefaultService = home.Id,
                    RouteRules = new[]
                    {
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleArgs
                        {
                            Priority = 1,
                            Service = home.Id,
                            HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleHeaderActionArgs
                            {
                                RequestHeadersToRemoves = new[]
                                {
                                    "RemoveMe2",
                                },
                            },
                            MatchRules = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs
                                {
                                    FullPathMatch = "a full path",
                                    HeaderMatches = new[]
                                    {
                                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs
                                        {
                                            HeaderName = "someheader",
                                            ExactMatch = "match this exactly",
                                            InvertMatch = true,
                                        },
                                    },
                                    QueryParameterMatches = new[]
                                    {
                                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs
                                        {
                                            Name = "a query parameter",
                                            PresentMatch = true,
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
            },
            Tests = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapTestArgs
                {
                    Service = home.Id,
                    Host = "hi.com",
                    Path = "/home",
                },
            },
        });
    
    });
    
    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.RegionUrlMap;
    import com.pulumi.gcp.compute.RegionUrlMapArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapTestArgs;
    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 default_ = new RegionHealthCheck("default", RegionHealthCheckArgs.builder()
                .name("health-check")
                .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                    .port(80)
                    .build())
                .build());
    
            var home = new RegionBackendService("home", RegionBackendServiceArgs.builder()
                .name("home")
                .protocol("HTTP")
                .timeoutSec(10)
                .healthChecks(default_.id())
                .loadBalancingScheme("INTERNAL_MANAGED")
                .build());
    
            var regionurlmap = new RegionUrlMap("regionurlmap", RegionUrlMapArgs.builder()
                .name("regionurlmap")
                .description("a description")
                .defaultService(home.id())
                .hostRules(RegionUrlMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("allpaths")
                    .build())
                .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                    .name("allpaths")
                    .defaultService(home.id())
                    .routeRules(RegionUrlMapPathMatcherRouteRuleArgs.builder()
                        .priority(1)
                        .service(home.id())
                        .headerAction(RegionUrlMapPathMatcherRouteRuleHeaderActionArgs.builder()
                            .requestHeadersToRemoves("RemoveMe2")
                            .build())
                        .matchRules(RegionUrlMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .fullPathMatch("a full path")
                            .headerMatches(RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs.builder()
                                .headerName("someheader")
                                .exactMatch("match this exactly")
                                .invertMatch(true)
                                .build())
                            .queryParameterMatches(RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                                .name("a query parameter")
                                .presentMatch(true)
                                .build())
                            .build())
                        .build())
                    .build())
                .tests(RegionUrlMapTestArgs.builder()
                    .service(home.id())
                    .host("hi.com")
                    .path("/home")
                    .build())
                .build());
    
        }
    }
    
    resources:
      regionurlmap:
        type: gcp:compute:RegionUrlMap
        properties:
          name: regionurlmap
          description: a description
          defaultService: ${home.id}
          hostRules:
            - hosts:
                - mysite.com
              pathMatcher: allpaths
          pathMatchers:
            - name: allpaths
              defaultService: ${home.id}
              routeRules:
                - priority: 1
                  service: ${home.id}
                  headerAction:
                    requestHeadersToRemoves:
                      - RemoveMe2
                  matchRules:
                    - fullPathMatch: a full path
                      headerMatches:
                        - headerName: someheader
                          exactMatch: match this exactly
                          invertMatch: true
                      queryParameterMatches:
                        - name: a query parameter
                          presentMatch: true
          tests:
            - service: ${home.id}
              host: hi.com
              path: /home
      home:
        type: gcp:compute:RegionBackendService
        properties:
          name: home
          protocol: HTTP
          timeoutSec: 10
          healthChecks: ${default.id}
          loadBalancingScheme: INTERNAL_MANAGED
      default:
        type: gcp:compute:RegionHealthCheck
        properties:
          name: health-check
          httpHealthCheck:
            port: 80
    

    Region Url Map Path Template Match

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const _default = new gcp.compute.RegionHealthCheck("default", {
        region: "us-central1",
        name: "health-check",
        checkIntervalSec: 1,
        timeoutSec: 1,
        httpHealthCheck: {
            port: 80,
            requestPath: "/",
        },
    });
    const home_backend = new gcp.compute.RegionBackendService("home-backend", {
        region: "us-central1",
        name: "home-service",
        portName: "http",
        protocol: "HTTP",
        timeoutSec: 10,
        loadBalancingScheme: "EXTERNAL_MANAGED",
        healthChecks: _default.id,
    });
    const cart_backend = new gcp.compute.RegionBackendService("cart-backend", {
        region: "us-central1",
        name: "cart-service",
        portName: "http",
        protocol: "HTTP",
        timeoutSec: 10,
        loadBalancingScheme: "EXTERNAL_MANAGED",
        healthChecks: _default.id,
    });
    const user_backend = new gcp.compute.RegionBackendService("user-backend", {
        region: "us-central1",
        name: "user-service",
        portName: "http",
        protocol: "HTTP",
        timeoutSec: 10,
        loadBalancingScheme: "EXTERNAL_MANAGED",
        healthChecks: _default.id,
    });
    const urlmap = new gcp.compute.RegionUrlMap("urlmap", {
        region: "us-central1",
        name: "urlmap",
        description: "a description",
        defaultService: home_backend.id,
        hostRules: [{
            hosts: ["mysite.com"],
            pathMatcher: "mysite",
        }],
        pathMatchers: [{
            name: "mysite",
            defaultService: home_backend.id,
            routeRules: [
                {
                    matchRules: [{
                        pathTemplateMatch: "/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}",
                    }],
                    service: cart_backend.id,
                    priority: 1,
                    routeAction: {
                        urlRewrite: {
                            pathTemplateRewrite: "/{username}-{cartid}/",
                        },
                    },
                },
                {
                    matchRules: [{
                        pathTemplateMatch: "/xyzwebservices/v2/xyz/users/*/accountinfo/*",
                    }],
                    service: user_backend.id,
                    priority: 2,
                },
            ],
        }],
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    default = gcp.compute.RegionHealthCheck("default",
        region="us-central1",
        name="health-check",
        check_interval_sec=1,
        timeout_sec=1,
        http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
            port=80,
            request_path="/",
        ))
    home_backend = gcp.compute.RegionBackendService("home-backend",
        region="us-central1",
        name="home-service",
        port_name="http",
        protocol="HTTP",
        timeout_sec=10,
        load_balancing_scheme="EXTERNAL_MANAGED",
        health_checks=default.id)
    cart_backend = gcp.compute.RegionBackendService("cart-backend",
        region="us-central1",
        name="cart-service",
        port_name="http",
        protocol="HTTP",
        timeout_sec=10,
        load_balancing_scheme="EXTERNAL_MANAGED",
        health_checks=default.id)
    user_backend = gcp.compute.RegionBackendService("user-backend",
        region="us-central1",
        name="user-service",
        port_name="http",
        protocol="HTTP",
        timeout_sec=10,
        load_balancing_scheme="EXTERNAL_MANAGED",
        health_checks=default.id)
    urlmap = gcp.compute.RegionUrlMap("urlmap",
        region="us-central1",
        name="urlmap",
        description="a description",
        default_service=home_backend.id,
        host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
            hosts=["mysite.com"],
            path_matcher="mysite",
        )],
        path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
            name="mysite",
            default_service=home_backend.id,
            route_rules=[
                gcp.compute.RegionUrlMapPathMatcherRouteRuleArgs(
                    match_rules=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs(
                        path_template_match="/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}",
                    )],
                    service=cart_backend.id,
                    priority=1,
                    route_action=gcp.compute.RegionUrlMapPathMatcherRouteRuleRouteActionArgs(
                        url_rewrite=gcp.compute.RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs(
                            path_template_rewrite="/{username}-{cartid}/",
                        ),
                    ),
                ),
                gcp.compute.RegionUrlMapPathMatcherRouteRuleArgs(
                    match_rules=[gcp.compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs(
                        path_template_match="/xyzwebservices/v2/xyz/users/*/accountinfo/*",
                    )],
                    service=user_backend.id,
                    priority=2,
                ),
            ],
        )])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := compute.NewRegionHealthCheck(ctx, "default", &compute.RegionHealthCheckArgs{
    			Region:           pulumi.String("us-central1"),
    			Name:             pulumi.String("health-check"),
    			CheckIntervalSec: pulumi.Int(1),
    			TimeoutSec:       pulumi.Int(1),
    			HttpHealthCheck: &compute.RegionHealthCheckHttpHealthCheckArgs{
    				Port:        pulumi.Int(80),
    				RequestPath: pulumi.String("/"),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionBackendService(ctx, "home-backend", &compute.RegionBackendServiceArgs{
    			Region:              pulumi.String("us-central1"),
    			Name:                pulumi.String("home-service"),
    			PortName:            pulumi.String("http"),
    			Protocol:            pulumi.String("HTTP"),
    			TimeoutSec:          pulumi.Int(10),
    			LoadBalancingScheme: pulumi.String("EXTERNAL_MANAGED"),
    			HealthChecks:        _default.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionBackendService(ctx, "cart-backend", &compute.RegionBackendServiceArgs{
    			Region:              pulumi.String("us-central1"),
    			Name:                pulumi.String("cart-service"),
    			PortName:            pulumi.String("http"),
    			Protocol:            pulumi.String("HTTP"),
    			TimeoutSec:          pulumi.Int(10),
    			LoadBalancingScheme: pulumi.String("EXTERNAL_MANAGED"),
    			HealthChecks:        _default.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionBackendService(ctx, "user-backend", &compute.RegionBackendServiceArgs{
    			Region:              pulumi.String("us-central1"),
    			Name:                pulumi.String("user-service"),
    			PortName:            pulumi.String("http"),
    			Protocol:            pulumi.String("HTTP"),
    			TimeoutSec:          pulumi.Int(10),
    			LoadBalancingScheme: pulumi.String("EXTERNAL_MANAGED"),
    			HealthChecks:        _default.ID(),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = compute.NewRegionUrlMap(ctx, "urlmap", &compute.RegionUrlMapArgs{
    			Region:         pulumi.String("us-central1"),
    			Name:           pulumi.String("urlmap"),
    			Description:    pulumi.String("a description"),
    			DefaultService: home_backend.ID(),
    			HostRules: compute.RegionUrlMapHostRuleArray{
    				&compute.RegionUrlMapHostRuleArgs{
    					Hosts: pulumi.StringArray{
    						pulumi.String("mysite.com"),
    					},
    					PathMatcher: pulumi.String("mysite"),
    				},
    			},
    			PathMatchers: compute.RegionUrlMapPathMatcherArray{
    				&compute.RegionUrlMapPathMatcherArgs{
    					Name:           pulumi.String("mysite"),
    					DefaultService: home_backend.ID(),
    					RouteRules: compute.RegionUrlMapPathMatcherRouteRuleArray{
    						&compute.RegionUrlMapPathMatcherRouteRuleArgs{
    							MatchRules: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArray{
    								&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs{
    									PathTemplateMatch: pulumi.String("/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}"),
    								},
    							},
    							Service:  cart_backend.ID(),
    							Priority: pulumi.Int(1),
    							RouteAction: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionArgs{
    								UrlRewrite: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs{
    									PathTemplateRewrite: pulumi.String("/{username}-{cartid}/"),
    								},
    							},
    						},
    						&compute.RegionUrlMapPathMatcherRouteRuleArgs{
    							MatchRules: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArray{
    								&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs{
    									PathTemplateMatch: pulumi.String("/xyzwebservices/v2/xyz/users/*/accountinfo/*"),
    								},
    							},
    							Service:  user_backend.ID(),
    							Priority: pulumi.Int(2),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var @default = new Gcp.Compute.RegionHealthCheck("default", new()
        {
            Region = "us-central1",
            Name = "health-check",
            CheckIntervalSec = 1,
            TimeoutSec = 1,
            HttpHealthCheck = new Gcp.Compute.Inputs.RegionHealthCheckHttpHealthCheckArgs
            {
                Port = 80,
                RequestPath = "/",
            },
        });
    
        var home_backend = new Gcp.Compute.RegionBackendService("home-backend", new()
        {
            Region = "us-central1",
            Name = "home-service",
            PortName = "http",
            Protocol = "HTTP",
            TimeoutSec = 10,
            LoadBalancingScheme = "EXTERNAL_MANAGED",
            HealthChecks = @default.Id,
        });
    
        var cart_backend = new Gcp.Compute.RegionBackendService("cart-backend", new()
        {
            Region = "us-central1",
            Name = "cart-service",
            PortName = "http",
            Protocol = "HTTP",
            TimeoutSec = 10,
            LoadBalancingScheme = "EXTERNAL_MANAGED",
            HealthChecks = @default.Id,
        });
    
        var user_backend = new Gcp.Compute.RegionBackendService("user-backend", new()
        {
            Region = "us-central1",
            Name = "user-service",
            PortName = "http",
            Protocol = "HTTP",
            TimeoutSec = 10,
            LoadBalancingScheme = "EXTERNAL_MANAGED",
            HealthChecks = @default.Id,
        });
    
        var urlmap = new Gcp.Compute.RegionUrlMap("urlmap", new()
        {
            Region = "us-central1",
            Name = "urlmap",
            Description = "a description",
            DefaultService = home_backend.Id,
            HostRules = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
                {
                    Hosts = new[]
                    {
                        "mysite.com",
                    },
                    PathMatcher = "mysite",
                },
            },
            PathMatchers = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
                {
                    Name = "mysite",
                    DefaultService = home_backend.Id,
                    RouteRules = new[]
                    {
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleArgs
                        {
                            MatchRules = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs
                                {
                                    PathTemplateMatch = "/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}",
                                },
                            },
                            Service = cart_backend.Id,
                            Priority = 1,
                            RouteAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionArgs
                            {
                                UrlRewrite = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs
                                {
                                    PathTemplateRewrite = "/{username}-{cartid}/",
                                },
                            },
                        },
                        new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleArgs
                        {
                            MatchRules = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs
                                {
                                    PathTemplateMatch = "/xyzwebservices/v2/xyz/users/*/accountinfo/*",
                                },
                            },
                            Service = user_backend.Id,
                            Priority = 2,
                        },
                    },
                },
            },
        });
    
    });
    
    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.RegionUrlMap;
    import com.pulumi.gcp.compute.RegionUrlMapArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapHostRuleArgs;
    import com.pulumi.gcp.compute.inputs.RegionUrlMapPathMatcherArgs;
    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 default_ = new RegionHealthCheck("default", RegionHealthCheckArgs.builder()
                .region("us-central1")
                .name("health-check")
                .checkIntervalSec(1)
                .timeoutSec(1)
                .httpHealthCheck(RegionHealthCheckHttpHealthCheckArgs.builder()
                    .port(80)
                    .requestPath("/")
                    .build())
                .build());
    
            var home_backend = new RegionBackendService("home-backend", RegionBackendServiceArgs.builder()
                .region("us-central1")
                .name("home-service")
                .portName("http")
                .protocol("HTTP")
                .timeoutSec(10)
                .loadBalancingScheme("EXTERNAL_MANAGED")
                .healthChecks(default_.id())
                .build());
    
            var cart_backend = new RegionBackendService("cart-backend", RegionBackendServiceArgs.builder()
                .region("us-central1")
                .name("cart-service")
                .portName("http")
                .protocol("HTTP")
                .timeoutSec(10)
                .loadBalancingScheme("EXTERNAL_MANAGED")
                .healthChecks(default_.id())
                .build());
    
            var user_backend = new RegionBackendService("user-backend", RegionBackendServiceArgs.builder()
                .region("us-central1")
                .name("user-service")
                .portName("http")
                .protocol("HTTP")
                .timeoutSec(10)
                .loadBalancingScheme("EXTERNAL_MANAGED")
                .healthChecks(default_.id())
                .build());
    
            var urlmap = new RegionUrlMap("urlmap", RegionUrlMapArgs.builder()
                .region("us-central1")
                .name("urlmap")
                .description("a description")
                .defaultService(home_backend.id())
                .hostRules(RegionUrlMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("mysite")
                    .build())
                .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
                    .name("mysite")
                    .defaultService(home_backend.id())
                    .routeRules(                
                        RegionUrlMapPathMatcherRouteRuleArgs.builder()
                            .matchRules(RegionUrlMapPathMatcherRouteRuleMatchRuleArgs.builder()
                                .pathTemplateMatch("/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}")
                                .build())
                            .service(cart_backend.id())
                            .priority(1)
                            .routeAction(RegionUrlMapPathMatcherRouteRuleRouteActionArgs.builder()
                                .urlRewrite(RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs.builder()
                                    .pathTemplateRewrite("/{username}-{cartid}/")
                                    .build())
                                .build())
                            .build(),
                        RegionUrlMapPathMatcherRouteRuleArgs.builder()
                            .matchRules(RegionUrlMapPathMatcherRouteRuleMatchRuleArgs.builder()
                                .pathTemplateMatch("/xyzwebservices/v2/xyz/users/*/accountinfo/*")
                                .build())
                            .service(user_backend.id())
                            .priority(2)
                            .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      urlmap:
        type: gcp:compute:RegionUrlMap
        properties:
          region: us-central1
          name: urlmap
          description: a description
          defaultService: ${["home-backend"].id}
          hostRules:
            - hosts:
                - mysite.com
              pathMatcher: mysite
          pathMatchers:
            - name: mysite
              defaultService: ${["home-backend"].id}
              routeRules:
                - matchRules:
                    - pathTemplateMatch: /xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}
                  service: ${["cart-backend"].id}
                  priority: 1
                  routeAction:
                    urlRewrite:
                      pathTemplateRewrite: /{username}-{cartid}/
                - matchRules:
                    - pathTemplateMatch: /xyzwebservices/v2/xyz/users/*/accountinfo/*
                  service: ${["user-backend"].id}
                  priority: 2
      home-backend:
        type: gcp:compute:RegionBackendService
        properties:
          region: us-central1
          name: home-service
          portName: http
          protocol: HTTP
          timeoutSec: 10
          loadBalancingScheme: EXTERNAL_MANAGED
          healthChecks: ${default.id}
      cart-backend:
        type: gcp:compute:RegionBackendService
        properties:
          region: us-central1
          name: cart-service
          portName: http
          protocol: HTTP
          timeoutSec: 10
          loadBalancingScheme: EXTERNAL_MANAGED
          healthChecks: ${default.id}
      user-backend:
        type: gcp:compute:RegionBackendService
        properties:
          region: us-central1
          name: user-service
          portName: http
          protocol: HTTP
          timeoutSec: 10
          loadBalancingScheme: EXTERNAL_MANAGED
          healthChecks: ${default.id}
      default:
        type: gcp:compute:RegionHealthCheck
        properties:
          region: us-central1
          name: health-check
          checkIntervalSec: 1
          timeoutSec: 1
          httpHealthCheck:
            port: 80
            requestPath: /
    

    Create RegionUrlMap Resource

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

    Constructor syntax

    new RegionUrlMap(name: string, args?: RegionUrlMapArgs, opts?: CustomResourceOptions);
    @overload
    def RegionUrlMap(resource_name: str,
                     args: Optional[RegionUrlMapArgs] = None,
                     opts: Optional[ResourceOptions] = None)
    
    @overload
    def RegionUrlMap(resource_name: str,
                     opts: Optional[ResourceOptions] = None,
                     default_route_action: Optional[RegionUrlMapDefaultRouteActionArgs] = None,
                     default_service: Optional[str] = None,
                     default_url_redirect: Optional[RegionUrlMapDefaultUrlRedirectArgs] = None,
                     description: Optional[str] = None,
                     host_rules: Optional[Sequence[RegionUrlMapHostRuleArgs]] = None,
                     name: Optional[str] = None,
                     path_matchers: Optional[Sequence[RegionUrlMapPathMatcherArgs]] = None,
                     project: Optional[str] = None,
                     region: Optional[str] = None,
                     tests: Optional[Sequence[RegionUrlMapTestArgs]] = None)
    func NewRegionUrlMap(ctx *Context, name string, args *RegionUrlMapArgs, opts ...ResourceOption) (*RegionUrlMap, error)
    public RegionUrlMap(string name, RegionUrlMapArgs? args = null, CustomResourceOptions? opts = null)
    public RegionUrlMap(String name, RegionUrlMapArgs args)
    public RegionUrlMap(String name, RegionUrlMapArgs args, CustomResourceOptions options)
    
    type: gcp:compute:RegionUrlMap
    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 RegionUrlMapArgs
    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 RegionUrlMapArgs
    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 RegionUrlMapArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args RegionUrlMapArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args RegionUrlMapArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var regionUrlMapResource = new Gcp.Compute.RegionUrlMap("regionUrlMapResource", new()
    {
        DefaultRouteAction = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionArgs
        {
            CorsPolicy = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionCorsPolicyArgs
            {
                AllowCredentials = false,
                AllowHeaders = new[]
                {
                    "string",
                },
                AllowMethods = new[]
                {
                    "string",
                },
                AllowOriginRegexes = new[]
                {
                    "string",
                },
                AllowOrigins = new[]
                {
                    "string",
                },
                Disabled = false,
                ExposeHeaders = new[]
                {
                    "string",
                },
                MaxAge = 0,
            },
            FaultInjectionPolicy = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs
            {
                Abort = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs
                {
                    HttpStatus = 0,
                    Percentage = 0,
                },
                Delay = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs
                {
                    FixedDelay = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs
                    {
                        Nanos = 0,
                        Seconds = "string",
                    },
                    Percentage = 0,
                },
            },
            RequestMirrorPolicy = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs
            {
                BackendService = "string",
            },
            RetryPolicy = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionRetryPolicyArgs
            {
                NumRetries = 0,
                PerTryTimeout = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs
                {
                    Nanos = 0,
                    Seconds = "string",
                },
                RetryConditions = new[]
                {
                    "string",
                },
            },
            Timeout = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionTimeoutArgs
            {
                Nanos = 0,
                Seconds = "string",
            },
            UrlRewrite = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionUrlRewriteArgs
            {
                HostRewrite = "string",
                PathPrefixRewrite = "string",
            },
            WeightedBackendServices = new[]
            {
                new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs
                {
                    BackendService = "string",
                    HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs
                    {
                        RequestHeadersToAdds = new[]
                        {
                            new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs
                            {
                                HeaderName = "string",
                                HeaderValue = "string",
                                Replace = false,
                            },
                        },
                        RequestHeadersToRemoves = new[]
                        {
                            "string",
                        },
                        ResponseHeadersToAdds = new[]
                        {
                            new Gcp.Compute.Inputs.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs
                            {
                                HeaderName = "string",
                                HeaderValue = "string",
                                Replace = false,
                            },
                        },
                        ResponseHeadersToRemoves = new[]
                        {
                            "string",
                        },
                    },
                    Weight = 0,
                },
            },
        },
        DefaultService = "string",
        DefaultUrlRedirect = new Gcp.Compute.Inputs.RegionUrlMapDefaultUrlRedirectArgs
        {
            StripQuery = false,
            HostRedirect = "string",
            HttpsRedirect = false,
            PathRedirect = "string",
            PrefixRedirect = "string",
            RedirectResponseCode = "string",
        },
        Description = "string",
        HostRules = new[]
        {
            new Gcp.Compute.Inputs.RegionUrlMapHostRuleArgs
            {
                Hosts = new[]
                {
                    "string",
                },
                PathMatcher = "string",
                Description = "string",
            },
        },
        Name = "string",
        PathMatchers = new[]
        {
            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherArgs
            {
                Name = "string",
                DefaultService = "string",
                DefaultUrlRedirect = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherDefaultUrlRedirectArgs
                {
                    StripQuery = false,
                    HostRedirect = "string",
                    HttpsRedirect = false,
                    PathRedirect = "string",
                    PrefixRedirect = "string",
                    RedirectResponseCode = "string",
                },
                Description = "string",
                PathRules = new[]
                {
                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleArgs
                    {
                        Paths = new[]
                        {
                            "string",
                        },
                        RouteAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionArgs
                        {
                            CorsPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs
                            {
                                Disabled = false,
                                AllowCredentials = false,
                                AllowHeaders = new[]
                                {
                                    "string",
                                },
                                AllowMethods = new[]
                                {
                                    "string",
                                },
                                AllowOriginRegexes = new[]
                                {
                                    "string",
                                },
                                AllowOrigins = new[]
                                {
                                    "string",
                                },
                                ExposeHeaders = new[]
                                {
                                    "string",
                                },
                                MaxAge = 0,
                            },
                            FaultInjectionPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs
                            {
                                Abort = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs
                                {
                                    HttpStatus = 0,
                                    Percentage = 0,
                                },
                                Delay = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs
                                {
                                    FixedDelay = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs
                                    {
                                        Seconds = "string",
                                        Nanos = 0,
                                    },
                                    Percentage = 0,
                                },
                            },
                            RequestMirrorPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs
                            {
                                BackendService = "string",
                            },
                            RetryPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs
                            {
                                NumRetries = 0,
                                PerTryTimeout = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs
                                {
                                    Seconds = "string",
                                    Nanos = 0,
                                },
                                RetryConditions = new[]
                                {
                                    "string",
                                },
                            },
                            Timeout = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs
                            {
                                Seconds = "string",
                                Nanos = 0,
                            },
                            UrlRewrite = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs
                            {
                                HostRewrite = "string",
                                PathPrefixRewrite = "string",
                            },
                            WeightedBackendServices = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs
                                {
                                    BackendService = "string",
                                    Weight = 0,
                                    HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs
                                    {
                                        RequestHeadersToAdds = new[]
                                        {
                                            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs
                                            {
                                                HeaderName = "string",
                                                HeaderValue = "string",
                                                Replace = false,
                                            },
                                        },
                                        RequestHeadersToRemoves = new[]
                                        {
                                            "string",
                                        },
                                        ResponseHeadersToAdds = new[]
                                        {
                                            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs
                                            {
                                                HeaderName = "string",
                                                HeaderValue = "string",
                                                Replace = false,
                                            },
                                        },
                                        ResponseHeadersToRemoves = new[]
                                        {
                                            "string",
                                        },
                                    },
                                },
                            },
                        },
                        Service = "string",
                        UrlRedirect = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherPathRuleUrlRedirectArgs
                        {
                            StripQuery = false,
                            HostRedirect = "string",
                            HttpsRedirect = false,
                            PathRedirect = "string",
                            PrefixRedirect = "string",
                            RedirectResponseCode = "string",
                        },
                    },
                },
                RouteRules = new[]
                {
                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleArgs
                    {
                        Priority = 0,
                        HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleHeaderActionArgs
                        {
                            RequestHeadersToAdds = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs
                                {
                                    HeaderName = "string",
                                    HeaderValue = "string",
                                    Replace = false,
                                },
                            },
                            RequestHeadersToRemoves = new[]
                            {
                                "string",
                            },
                            ResponseHeadersToAdds = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs
                                {
                                    HeaderName = "string",
                                    HeaderValue = "string",
                                    Replace = false,
                                },
                            },
                            ResponseHeadersToRemoves = new[]
                            {
                                "string",
                            },
                        },
                        MatchRules = new[]
                        {
                            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs
                            {
                                FullPathMatch = "string",
                                HeaderMatches = new[]
                                {
                                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs
                                    {
                                        HeaderName = "string",
                                        ExactMatch = "string",
                                        InvertMatch = false,
                                        PrefixMatch = "string",
                                        PresentMatch = false,
                                        RangeMatch = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs
                                        {
                                            RangeEnd = 0,
                                            RangeStart = 0,
                                        },
                                        RegexMatch = "string",
                                        SuffixMatch = "string",
                                    },
                                },
                                IgnoreCase = false,
                                MetadataFilters = new[]
                                {
                                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs
                                    {
                                        FilterLabels = new[]
                                        {
                                            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs
                                            {
                                                Name = "string",
                                                Value = "string",
                                            },
                                        },
                                        FilterMatchCriteria = "string",
                                    },
                                },
                                PathTemplateMatch = "string",
                                PrefixMatch = "string",
                                QueryParameterMatches = new[]
                                {
                                    new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs
                                    {
                                        Name = "string",
                                        ExactMatch = "string",
                                        PresentMatch = false,
                                        RegexMatch = "string",
                                    },
                                },
                                RegexMatch = "string",
                            },
                        },
                        RouteAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionArgs
                        {
                            CorsPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs
                            {
                                AllowCredentials = false,
                                AllowHeaders = new[]
                                {
                                    "string",
                                },
                                AllowMethods = new[]
                                {
                                    "string",
                                },
                                AllowOriginRegexes = new[]
                                {
                                    "string",
                                },
                                AllowOrigins = new[]
                                {
                                    "string",
                                },
                                Disabled = false,
                                ExposeHeaders = new[]
                                {
                                    "string",
                                },
                                MaxAge = 0,
                            },
                            FaultInjectionPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs
                            {
                                Abort = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs
                                {
                                    HttpStatus = 0,
                                    Percentage = 0,
                                },
                                Delay = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs
                                {
                                    FixedDelay = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs
                                    {
                                        Seconds = "string",
                                        Nanos = 0,
                                    },
                                    Percentage = 0,
                                },
                            },
                            RequestMirrorPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs
                            {
                                BackendService = "string",
                            },
                            RetryPolicy = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs
                            {
                                NumRetries = 0,
                                PerTryTimeout = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs
                                {
                                    Seconds = "string",
                                    Nanos = 0,
                                },
                                RetryConditions = new[]
                                {
                                    "string",
                                },
                            },
                            Timeout = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs
                            {
                                Seconds = "string",
                                Nanos = 0,
                            },
                            UrlRewrite = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs
                            {
                                HostRewrite = "string",
                                PathPrefixRewrite = "string",
                                PathTemplateRewrite = "string",
                            },
                            WeightedBackendServices = new[]
                            {
                                new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs
                                {
                                    BackendService = "string",
                                    Weight = 0,
                                    HeaderAction = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs
                                    {
                                        RequestHeadersToAdds = new[]
                                        {
                                            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs
                                            {
                                                HeaderName = "string",
                                                HeaderValue = "string",
                                                Replace = false,
                                            },
                                        },
                                        RequestHeadersToRemoves = new[]
                                        {
                                            "string",
                                        },
                                        ResponseHeadersToAdds = new[]
                                        {
                                            new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs
                                            {
                                                HeaderName = "string",
                                                HeaderValue = "string",
                                                Replace = false,
                                            },
                                        },
                                        ResponseHeadersToRemoves = new[]
                                        {
                                            "string",
                                        },
                                    },
                                },
                            },
                        },
                        Service = "string",
                        UrlRedirect = new Gcp.Compute.Inputs.RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs
                        {
                            HostRedirect = "string",
                            HttpsRedirect = false,
                            PathRedirect = "string",
                            PrefixRedirect = "string",
                            RedirectResponseCode = "string",
                            StripQuery = false,
                        },
                    },
                },
            },
        },
        Project = "string",
        Region = "string",
        Tests = new[]
        {
            new Gcp.Compute.Inputs.RegionUrlMapTestArgs
            {
                Host = "string",
                Path = "string",
                Service = "string",
                Description = "string",
            },
        },
    });
    
    example, err := compute.NewRegionUrlMap(ctx, "regionUrlMapResource", &compute.RegionUrlMapArgs{
    	DefaultRouteAction: &compute.RegionUrlMapDefaultRouteActionArgs{
    		CorsPolicy: &compute.RegionUrlMapDefaultRouteActionCorsPolicyArgs{
    			AllowCredentials: pulumi.Bool(false),
    			AllowHeaders: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			AllowMethods: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			AllowOriginRegexes: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			AllowOrigins: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Disabled: pulumi.Bool(false),
    			ExposeHeaders: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			MaxAge: pulumi.Int(0),
    		},
    		FaultInjectionPolicy: &compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs{
    			Abort: &compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs{
    				HttpStatus: pulumi.Int(0),
    				Percentage: pulumi.Float64(0),
    			},
    			Delay: &compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs{
    				FixedDelay: &compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs{
    					Nanos:   pulumi.Int(0),
    					Seconds: pulumi.String("string"),
    				},
    				Percentage: pulumi.Float64(0),
    			},
    		},
    		RequestMirrorPolicy: &compute.RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs{
    			BackendService: pulumi.String("string"),
    		},
    		RetryPolicy: &compute.RegionUrlMapDefaultRouteActionRetryPolicyArgs{
    			NumRetries: pulumi.Int(0),
    			PerTryTimeout: &compute.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs{
    				Nanos:   pulumi.Int(0),
    				Seconds: pulumi.String("string"),
    			},
    			RetryConditions: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    		},
    		Timeout: &compute.RegionUrlMapDefaultRouteActionTimeoutArgs{
    			Nanos:   pulumi.Int(0),
    			Seconds: pulumi.String("string"),
    		},
    		UrlRewrite: &compute.RegionUrlMapDefaultRouteActionUrlRewriteArgs{
    			HostRewrite:       pulumi.String("string"),
    			PathPrefixRewrite: pulumi.String("string"),
    		},
    		WeightedBackendServices: compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceArray{
    			&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs{
    				BackendService: pulumi.String("string"),
    				HeaderAction: &compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs{
    					RequestHeadersToAdds: compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArray{
    						&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs{
    							HeaderName:  pulumi.String("string"),
    							HeaderValue: pulumi.String("string"),
    							Replace:     pulumi.Bool(false),
    						},
    					},
    					RequestHeadersToRemoves: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    					ResponseHeadersToAdds: compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArray{
    						&compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs{
    							HeaderName:  pulumi.String("string"),
    							HeaderValue: pulumi.String("string"),
    							Replace:     pulumi.Bool(false),
    						},
    					},
    					ResponseHeadersToRemoves: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    				},
    				Weight: pulumi.Int(0),
    			},
    		},
    	},
    	DefaultService: pulumi.String("string"),
    	DefaultUrlRedirect: &compute.RegionUrlMapDefaultUrlRedirectArgs{
    		StripQuery:           pulumi.Bool(false),
    		HostRedirect:         pulumi.String("string"),
    		HttpsRedirect:        pulumi.Bool(false),
    		PathRedirect:         pulumi.String("string"),
    		PrefixRedirect:       pulumi.String("string"),
    		RedirectResponseCode: pulumi.String("string"),
    	},
    	Description: pulumi.String("string"),
    	HostRules: compute.RegionUrlMapHostRuleArray{
    		&compute.RegionUrlMapHostRuleArgs{
    			Hosts: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			PathMatcher: pulumi.String("string"),
    			Description: pulumi.String("string"),
    		},
    	},
    	Name: pulumi.String("string"),
    	PathMatchers: compute.RegionUrlMapPathMatcherArray{
    		&compute.RegionUrlMapPathMatcherArgs{
    			Name:           pulumi.String("string"),
    			DefaultService: pulumi.String("string"),
    			DefaultUrlRedirect: &compute.RegionUrlMapPathMatcherDefaultUrlRedirectArgs{
    				StripQuery:           pulumi.Bool(false),
    				HostRedirect:         pulumi.String("string"),
    				HttpsRedirect:        pulumi.Bool(false),
    				PathRedirect:         pulumi.String("string"),
    				PrefixRedirect:       pulumi.String("string"),
    				RedirectResponseCode: pulumi.String("string"),
    			},
    			Description: pulumi.String("string"),
    			PathRules: compute.RegionUrlMapPathMatcherPathRuleArray{
    				&compute.RegionUrlMapPathMatcherPathRuleArgs{
    					Paths: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    					RouteAction: &compute.RegionUrlMapPathMatcherPathRuleRouteActionArgs{
    						CorsPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs{
    							Disabled:         pulumi.Bool(false),
    							AllowCredentials: pulumi.Bool(false),
    							AllowHeaders: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							AllowMethods: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							AllowOriginRegexes: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							AllowOrigins: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							ExposeHeaders: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							MaxAge: pulumi.Int(0),
    						},
    						FaultInjectionPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs{
    							Abort: &compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs{
    								HttpStatus: pulumi.Int(0),
    								Percentage: pulumi.Float64(0),
    							},
    							Delay: &compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs{
    								FixedDelay: &compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs{
    									Seconds: pulumi.String("string"),
    									Nanos:   pulumi.Int(0),
    								},
    								Percentage: pulumi.Float64(0),
    							},
    						},
    						RequestMirrorPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs{
    							BackendService: pulumi.String("string"),
    						},
    						RetryPolicy: &compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs{
    							NumRetries: pulumi.Int(0),
    							PerTryTimeout: &compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs{
    								Seconds: pulumi.String("string"),
    								Nanos:   pulumi.Int(0),
    							},
    							RetryConditions: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    						},
    						Timeout: &compute.RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs{
    							Seconds: pulumi.String("string"),
    							Nanos:   pulumi.Int(0),
    						},
    						UrlRewrite: &compute.RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs{
    							HostRewrite:       pulumi.String("string"),
    							PathPrefixRewrite: pulumi.String("string"),
    						},
    						WeightedBackendServices: compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArray{
    							&compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs{
    								BackendService: pulumi.String("string"),
    								Weight:         pulumi.Int(0),
    								HeaderAction: &compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs{
    									RequestHeadersToAdds: compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArray{
    										&compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs{
    											HeaderName:  pulumi.String("string"),
    											HeaderValue: pulumi.String("string"),
    											Replace:     pulumi.Bool(false),
    										},
    									},
    									RequestHeadersToRemoves: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									ResponseHeadersToAdds: compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArray{
    										&compute.RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs{
    											HeaderName:  pulumi.String("string"),
    											HeaderValue: pulumi.String("string"),
    											Replace:     pulumi.Bool(false),
    										},
    									},
    									ResponseHeadersToRemoves: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    								},
    							},
    						},
    					},
    					Service: pulumi.String("string"),
    					UrlRedirect: &compute.RegionUrlMapPathMatcherPathRuleUrlRedirectArgs{
    						StripQuery:           pulumi.Bool(false),
    						HostRedirect:         pulumi.String("string"),
    						HttpsRedirect:        pulumi.Bool(false),
    						PathRedirect:         pulumi.String("string"),
    						PrefixRedirect:       pulumi.String("string"),
    						RedirectResponseCode: pulumi.String("string"),
    					},
    				},
    			},
    			RouteRules: compute.RegionUrlMapPathMatcherRouteRuleArray{
    				&compute.RegionUrlMapPathMatcherRouteRuleArgs{
    					Priority: pulumi.Int(0),
    					HeaderAction: &compute.RegionUrlMapPathMatcherRouteRuleHeaderActionArgs{
    						RequestHeadersToAdds: compute.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArray{
    							&compute.RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs{
    								HeaderName:  pulumi.String("string"),
    								HeaderValue: pulumi.String("string"),
    								Replace:     pulumi.Bool(false),
    							},
    						},
    						RequestHeadersToRemoves: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    						ResponseHeadersToAdds: compute.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArray{
    							&compute.RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs{
    								HeaderName:  pulumi.String("string"),
    								HeaderValue: pulumi.String("string"),
    								Replace:     pulumi.Bool(false),
    							},
    						},
    						ResponseHeadersToRemoves: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    					},
    					MatchRules: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArray{
    						&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleArgs{
    							FullPathMatch: pulumi.String("string"),
    							HeaderMatches: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArray{
    								&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs{
    									HeaderName:   pulumi.String("string"),
    									ExactMatch:   pulumi.String("string"),
    									InvertMatch:  pulumi.Bool(false),
    									PrefixMatch:  pulumi.String("string"),
    									PresentMatch: pulumi.Bool(false),
    									RangeMatch: &compute.RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs{
    										RangeEnd:   pulumi.Int(0),
    										RangeStart: pulumi.Int(0),
    									},
    									RegexMatch:  pulumi.String("string"),
    									SuffixMatch: pulumi.String("string"),
    								},
    							},
    							IgnoreCase: pulumi.Bool(false),
    							MetadataFilters: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArray{
    								&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs{
    									FilterLabels: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArray{
    										&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs{
    											Name:  pulumi.String("string"),
    											Value: pulumi.String("string"),
    										},
    									},
    									FilterMatchCriteria: pulumi.String("string"),
    								},
    							},
    							PathTemplateMatch: pulumi.String("string"),
    							PrefixMatch:       pulumi.String("string"),
    							QueryParameterMatches: compute.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArray{
    								&compute.RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs{
    									Name:         pulumi.String("string"),
    									ExactMatch:   pulumi.String("string"),
    									PresentMatch: pulumi.Bool(false),
    									RegexMatch:   pulumi.String("string"),
    								},
    							},
    							RegexMatch: pulumi.String("string"),
    						},
    					},
    					RouteAction: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionArgs{
    						CorsPolicy: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs{
    							AllowCredentials: pulumi.Bool(false),
    							AllowHeaders: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							AllowMethods: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							AllowOriginRegexes: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							AllowOrigins: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Disabled: pulumi.Bool(false),
    							ExposeHeaders: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							MaxAge: pulumi.Int(0),
    						},
    						FaultInjectionPolicy: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs{
    							Abort: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs{
    								HttpStatus: pulumi.Int(0),
    								Percentage: pulumi.Float64(0),
    							},
    							Delay: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs{
    								FixedDelay: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs{
    									Seconds: pulumi.String("string"),
    									Nanos:   pulumi.Int(0),
    								},
    								Percentage: pulumi.Float64(0),
    							},
    						},
    						RequestMirrorPolicy: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs{
    							BackendService: pulumi.String("string"),
    						},
    						RetryPolicy: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs{
    							NumRetries: pulumi.Int(0),
    							PerTryTimeout: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs{
    								Seconds: pulumi.String("string"),
    								Nanos:   pulumi.Int(0),
    							},
    							RetryConditions: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    						},
    						Timeout: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs{
    							Seconds: pulumi.String("string"),
    							Nanos:   pulumi.Int(0),
    						},
    						UrlRewrite: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs{
    							HostRewrite:         pulumi.String("string"),
    							PathPrefixRewrite:   pulumi.String("string"),
    							PathTemplateRewrite: pulumi.String("string"),
    						},
    						WeightedBackendServices: compute.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArray{
    							&compute.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs{
    								BackendService: pulumi.String("string"),
    								Weight:         pulumi.Int(0),
    								HeaderAction: &compute.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs{
    									RequestHeadersToAdds: compute.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArray{
    										&compute.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs{
    											HeaderName:  pulumi.String("string"),
    											HeaderValue: pulumi.String("string"),
    											Replace:     pulumi.Bool(false),
    										},
    									},
    									RequestHeadersToRemoves: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									ResponseHeadersToAdds: compute.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArray{
    										&compute.RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs{
    											HeaderName:  pulumi.String("string"),
    											HeaderValue: pulumi.String("string"),
    											Replace:     pulumi.Bool(false),
    										},
    									},
    									ResponseHeadersToRemoves: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    								},
    							},
    						},
    					},
    					Service: pulumi.String("string"),
    					UrlRedirect: &compute.RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs{
    						HostRedirect:         pulumi.String("string"),
    						HttpsRedirect:        pulumi.Bool(false),
    						PathRedirect:         pulumi.String("string"),
    						PrefixRedirect:       pulumi.String("string"),
    						RedirectResponseCode: pulumi.String("string"),
    						StripQuery:           pulumi.Bool(false),
    					},
    				},
    			},
    		},
    	},
    	Project: pulumi.String("string"),
    	Region:  pulumi.String("string"),
    	Tests: compute.RegionUrlMapTestArray{
    		&compute.RegionUrlMapTestArgs{
    			Host:        pulumi.String("string"),
    			Path:        pulumi.String("string"),
    			Service:     pulumi.String("string"),
    			Description: pulumi.String("string"),
    		},
    	},
    })
    
    var regionUrlMapResource = new RegionUrlMap("regionUrlMapResource", RegionUrlMapArgs.builder()
        .defaultRouteAction(RegionUrlMapDefaultRouteActionArgs.builder()
            .corsPolicy(RegionUrlMapDefaultRouteActionCorsPolicyArgs.builder()
                .allowCredentials(false)
                .allowHeaders("string")
                .allowMethods("string")
                .allowOriginRegexes("string")
                .allowOrigins("string")
                .disabled(false)
                .exposeHeaders("string")
                .maxAge(0)
                .build())
            .faultInjectionPolicy(RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs.builder()
                .abort(RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs.builder()
                    .httpStatus(0)
                    .percentage(0)
                    .build())
                .delay(RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs.builder()
                    .fixedDelay(RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs.builder()
                        .nanos(0)
                        .seconds("string")
                        .build())
                    .percentage(0)
                    .build())
                .build())
            .requestMirrorPolicy(RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs.builder()
                .backendService("string")
                .build())
            .retryPolicy(RegionUrlMapDefaultRouteActionRetryPolicyArgs.builder()
                .numRetries(0)
                .perTryTimeout(RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs.builder()
                    .nanos(0)
                    .seconds("string")
                    .build())
                .retryConditions("string")
                .build())
            .timeout(RegionUrlMapDefaultRouteActionTimeoutArgs.builder()
                .nanos(0)
                .seconds("string")
                .build())
            .urlRewrite(RegionUrlMapDefaultRouteActionUrlRewriteArgs.builder()
                .hostRewrite("string")
                .pathPrefixRewrite("string")
                .build())
            .weightedBackendServices(RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs.builder()
                .backendService("string")
                .headerAction(RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                    .requestHeadersToAdds(RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                        .headerName("string")
                        .headerValue("string")
                        .replace(false)
                        .build())
                    .requestHeadersToRemoves("string")
                    .responseHeadersToAdds(RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                        .headerName("string")
                        .headerValue("string")
                        .replace(false)
                        .build())
                    .responseHeadersToRemoves("string")
                    .build())
                .weight(0)
                .build())
            .build())
        .defaultService("string")
        .defaultUrlRedirect(RegionUrlMapDefaultUrlRedirectArgs.builder()
            .stripQuery(false)
            .hostRedirect("string")
            .httpsRedirect(false)
            .pathRedirect("string")
            .prefixRedirect("string")
            .redirectResponseCode("string")
            .build())
        .description("string")
        .hostRules(RegionUrlMapHostRuleArgs.builder()
            .hosts("string")
            .pathMatcher("string")
            .description("string")
            .build())
        .name("string")
        .pathMatchers(RegionUrlMapPathMatcherArgs.builder()
            .name("string")
            .defaultService("string")
            .defaultUrlRedirect(RegionUrlMapPathMatcherDefaultUrlRedirectArgs.builder()
                .stripQuery(false)
                .hostRedirect("string")
                .httpsRedirect(false)
                .pathRedirect("string")
                .prefixRedirect("string")
                .redirectResponseCode("string")
                .build())
            .description("string")
            .pathRules(RegionUrlMapPathMatcherPathRuleArgs.builder()
                .paths("string")
                .routeAction(RegionUrlMapPathMatcherPathRuleRouteActionArgs.builder()
                    .corsPolicy(RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs.builder()
                        .disabled(false)
                        .allowCredentials(false)
                        .allowHeaders("string")
                        .allowMethods("string")
                        .allowOriginRegexes("string")
                        .allowOrigins("string")
                        .exposeHeaders("string")
                        .maxAge(0)
                        .build())
                    .faultInjectionPolicy(RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs.builder()
                        .abort(RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs.builder()
                            .httpStatus(0)
                            .percentage(0)
                            .build())
                        .delay(RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs.builder()
                            .fixedDelay(RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs.builder()
                                .seconds("string")
                                .nanos(0)
                                .build())
                            .percentage(0)
                            .build())
                        .build())
                    .requestMirrorPolicy(RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs.builder()
                        .backendService("string")
                        .build())
                    .retryPolicy(RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs.builder()
                        .numRetries(0)
                        .perTryTimeout(RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs.builder()
                            .seconds("string")
                            .nanos(0)
                            .build())
                        .retryConditions("string")
                        .build())
                    .timeout(RegionUrlMapPathMatcherPathRuleRouteActionTimeoutArgs.builder()
                        .seconds("string")
                        .nanos(0)
                        .build())
                    .urlRewrite(RegionUrlMapPathMatcherPathRuleRouteActionUrlRewriteArgs.builder()
                        .hostRewrite("string")
                        .pathPrefixRewrite("string")
                        .build())
                    .weightedBackendServices(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs.builder()
                        .backendService("string")
                        .weight(0)
                        .headerAction(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                            .requestHeadersToAdds(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                                .headerName("string")
                                .headerValue("string")
                                .replace(false)
                                .build())
                            .requestHeadersToRemoves("string")
                            .responseHeadersToAdds(RegionUrlMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                .headerName("string")
                                .headerValue("string")
                                .replace(false)
                                .build())
                            .responseHeadersToRemoves("string")
                            .build())
                        .build())
                    .build())
                .service("string")
                .urlRedirect(RegionUrlMapPathMatcherPathRuleUrlRedirectArgs.builder()
                    .stripQuery(false)
                    .hostRedirect("string")
                    .httpsRedirect(false)
                    .pathRedirect("string")
                    .prefixRedirect("string")
                    .redirectResponseCode("string")
                    .build())
                .build())
            .routeRules(RegionUrlMapPathMatcherRouteRuleArgs.builder()
                .priority(0)
                .headerAction(RegionUrlMapPathMatcherRouteRuleHeaderActionArgs.builder()
                    .requestHeadersToAdds(RegionUrlMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs.builder()
                        .headerName("string")
                        .headerValue("string")
                        .replace(false)
                        .build())
                    .requestHeadersToRemoves("string")
                    .responseHeadersToAdds(RegionUrlMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs.builder()
                        .headerName("string")
                        .headerValue("string")
                        .replace(false)
                        .build())
                    .responseHeadersToRemoves("string")
                    .build())
                .matchRules(RegionUrlMapPathMatcherRouteRuleMatchRuleArgs.builder()
                    .fullPathMatch("string")
                    .headerMatches(RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs.builder()
                        .headerName("string")
                        .exactMatch("string")
                        .invertMatch(false)
                        .prefixMatch("string")
                        .presentMatch(false)
                        .rangeMatch(RegionUrlMapPathMatcherRouteRuleMatchRuleHeaderMatchRangeMatchArgs.builder()
                            .rangeEnd(0)
                            .rangeStart(0)
                            .build())
                        .regexMatch("string")
                        .suffixMatch("string")
                        .build())
                    .ignoreCase(false)
                    .metadataFilters(RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs.builder()
                        .filterLabels(RegionUrlMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs.builder()
                            .name("string")
                            .value("string")
                            .build())
                        .filterMatchCriteria("string")
                        .build())
                    .pathTemplateMatch("string")
                    .prefixMatch("string")
                    .queryParameterMatches(RegionUrlMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                        .name("string")
                        .exactMatch("string")
                        .presentMatch(false)
                        .regexMatch("string")
                        .build())
                    .regexMatch("string")
                    .build())
                .routeAction(RegionUrlMapPathMatcherRouteRuleRouteActionArgs.builder()
                    .corsPolicy(RegionUrlMapPathMatcherRouteRuleRouteActionCorsPolicyArgs.builder()
                        .allowCredentials(false)
                        .allowHeaders("string")
                        .allowMethods("string")
                        .allowOriginRegexes("string")
                        .allowOrigins("string")
                        .disabled(false)
                        .exposeHeaders("string")
                        .maxAge(0)
                        .build())
                    .faultInjectionPolicy(RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyArgs.builder()
                        .abort(RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyAbortArgs.builder()
                            .httpStatus(0)
                            .percentage(0)
                            .build())
                        .delay(RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayArgs.builder()
                            .fixedDelay(RegionUrlMapPathMatcherRouteRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs.builder()
                                .seconds("string")
                                .nanos(0)
                                .build())
                            .percentage(0)
                            .build())
                        .build())
                    .requestMirrorPolicy(RegionUrlMapPathMatcherRouteRuleRouteActionRequestMirrorPolicyArgs.builder()
                        .backendService("string")
                        .build())
                    .retryPolicy(RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyArgs.builder()
                        .numRetries(0)
                        .perTryTimeout(RegionUrlMapPathMatcherRouteRuleRouteActionRetryPolicyPerTryTimeoutArgs.builder()
                            .seconds("string")
                            .nanos(0)
                            .build())
                        .retryConditions("string")
                        .build())
                    .timeout(RegionUrlMapPathMatcherRouteRuleRouteActionTimeoutArgs.builder()
                        .seconds("string")
                        .nanos(0)
                        .build())
                    .urlRewrite(RegionUrlMapPathMatcherRouteRuleRouteActionUrlRewriteArgs.builder()
                        .hostRewrite("string")
                        .pathPrefixRewrite("string")
                        .pathTemplateRewrite("string")
                        .build())
                    .weightedBackendServices(RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceArgs.builder()
                        .backendService("string")
                        .weight(0)
                        .headerAction(RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                            .requestHeadersToAdds(RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                                .headerName("string")
                                .headerValue("string")
                                .replace(false)
                                .build())
                            .requestHeadersToRemoves("string")
                            .responseHeadersToAdds(RegionUrlMapPathMatcherRouteRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                .headerName("string")
                                .headerValue("string")
                                .replace(false)
                                .build())
                            .responseHeadersToRemoves("string")
                            .build())
                        .build())
                    .build())
                .service("string")
                .urlRedirect(RegionUrlMapPathMatcherRouteRuleUrlRedirectArgs.builder()
                    .hostRedirect("string")
                    .httpsRedirect(false)
                    .pathRedirect("string")
                    .prefixRedirect("string")
                    .redirectResponseCode("string")
                    .stripQuery(false)
                    .build())
                .build())
            .build())
        .project("string")
        .region("string")
        .tests(RegionUrlMapTestArgs.builder()
            .host("string")
            .path("string")
            .service("string")
            .description("string")
            .build())
        .build());
    
    region_url_map_resource = gcp.compute.RegionUrlMap("regionUrlMapResource",
        default_route_action=gcp.compute.RegionUrlMapDefaultRouteActionArgs(
            cors_policy=gcp.compute.RegionUrlMapDefaultRouteActionCorsPolicyArgs(
                allow_credentials=False,
                allow_headers=["string"],
                allow_methods=["string"],
                allow_origin_regexes=["string"],
                allow_origins=["string"],
                disabled=False,
                expose_headers=["string"],
                max_age=0,
            ),
            fault_injection_policy=gcp.compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyArgs(
                abort=gcp.compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyAbortArgs(
                    http_status=0,
                    percentage=0,
                ),
                delay=gcp.compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayArgs(
                    fixed_delay=gcp.compute.RegionUrlMapDefaultRouteActionFaultInjectionPolicyDelayFixedDelayArgs(
                        nanos=0,
                        seconds="string",
                    ),
                    percentage=0,
                ),
            ),
            request_mirror_policy=gcp.compute.RegionUrlMapDefaultRouteActionRequestMirrorPolicyArgs(
                backend_service="string",
            ),
            retry_policy=gcp.compute.RegionUrlMapDefaultRouteActionRetryPolicyArgs(
                num_retries=0,
                per_try_timeout=gcp.compute.RegionUrlMapDefaultRouteActionRetryPolicyPerTryTimeoutArgs(
                    nanos=0,
                    seconds="string",
                ),
                retry_conditions=["string"],
            ),
            timeout=gcp.compute.RegionUrlMapDefaultRouteActionTimeoutArgs(
                nanos=0,
                seconds="string",
            ),
            url_rewrite=gcp.compute.RegionUrlMapDefaultRouteActionUrlRewriteArgs(
                host_rewrite="string",
                path_prefix_rewrite="string",
            ),
            weighted_backend_services=[gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceArgs(
                backend_service="string",
                header_action=gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionArgs(
                    request_headers_to_adds=[gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs(
                        header_name="string",
                        header_value="string",
                        replace=False,
                    )],
                    request_headers_to_removes=["string"],
                    response_headers_to_adds=[gcp.compute.RegionUrlMapDefaultRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs(
                        header_name="string",
                        header_value="string",
                        replace=False,
                    )],
                    response_headers_to_removes=["string"],
                ),
                weight=0,
            )],
        ),
        default_service="string",
        default_url_redirect=gcp.compute.RegionUrlMapDefaultUrlRedirectArgs(
            strip_query=False,
            host_redirect="string",
            https_redirect=False,
            path_redirect="string",
            prefix_redirect="string",
            redirect_response_code="string",
        ),
        description="string",
        host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
            hosts=["string"],
            path_matcher="string",
            description="string",
        )],
        name="string",
        path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
            name="string",
            default_service="string",
            default_url_redirect=gcp.compute.RegionUrlMapPathMatcherDefaultUrlRedirectArgs(
                strip_query=False,
                host_redirect="string",
                https_redirect=False,
                path_redirect="string",
                prefix_redirect="string",
                redirect_response_code="string",
            ),
            description="string",
            path_rules=[gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
                paths=["string"],
                route_action=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionArgs(
                    cors_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionCorsPolicyArgs(
                        disabled=False,
                        allow_credentials=False,
                        allow_headers=["string"],
                        allow_methods=["string"],
                        allow_origin_regexes=["string"],
                        allow_origins=["string"],
                        expose_headers=["string"],
                        max_age=0,
                    ),
                    fault_injection_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs(
                        abort=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs(
                            http_status=0,
                            percentage=0,
                        ),
                        delay=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs(
                            fixed_delay=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs(
                                seconds="string",
                                nanos=0,
                            ),
                            percentage=0,
                        ),
                    ),
                    request_mirror_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs(
                        backend_service="string",
                    ),
                    retry_policy=gcp.compute.RegionUrlMapPathMatcherPathRuleRouteActionRetryPolicyArgs(
                        num_retries=0,
                        per_try_timeout=gcp.c