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

URLMap

class URLMap : KotlinCustomResource

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. To get more information about UrlMap, see:

Example Usage

Url Map Bucket And Service

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HttpHealthCheck;
import com.pulumi.gcp.compute.HttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.compute.BackendBucket;
import com.pulumi.gcp.compute.BackendBucketArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
import com.pulumi.gcp.compute.inputs.URLMapTestArgs;
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 HttpHealthCheck("default", HttpHealthCheckArgs.builder()
            .requestPath("/")
            .checkIntervalSec(1)
            .timeoutSec(1)
            .build());
        var login = new BackendService("login", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(default_.id())
            .build());
        var staticBucket = new Bucket("staticBucket", BucketArgs.builder()
            .location("US")
            .build());
        var staticBackendBucket = new BackendBucket("staticBackendBucket", BackendBucketArgs.builder()
            .bucketName(staticBucket.name())
            .enableCdn(true)
            .build());
        var urlmap = new URLMap("urlmap", URLMapArgs.builder()
            .description("a description")
            .defaultService(staticBackendBucket.id())
            .hostRules(
                URLMapHostRuleArgs.builder()
                    .hosts("mysite.com")
                    .pathMatcher("mysite")
                    .build(),
                URLMapHostRuleArgs.builder()
                    .hosts("myothersite.com")
                    .pathMatcher("otherpaths")
                    .build())
            .pathMatchers(
                URLMapPathMatcherArgs.builder()
                    .name("mysite")
                    .defaultService(staticBackendBucket.id())
                    .pathRules(
                        URLMapPathMatcherPathRuleArgs.builder()
                            .paths("/home")
                            .service(staticBackendBucket.id())
                            .build(),
                        URLMapPathMatcherPathRuleArgs.builder()
                            .paths("/login")
                            .service(login.id())
                            .build(),
                        URLMapPathMatcherPathRuleArgs.builder()
                            .paths("/static")
                            .service(staticBackendBucket.id())
                            .build())
                    .build(),
                URLMapPathMatcherArgs.builder()
                    .name("otherpaths")
                    .defaultService(staticBackendBucket.id())
                    .build())
            .tests(URLMapTestArgs.builder()
                .service(staticBackendBucket.id())
                .host("example.com")
                .path("/home")
                .build())
            .build());
    }
}
Content copied to clipboard

Url Map Traffic Director Route

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HealthCheck;
import com.pulumi.gcp.compute.HealthCheckArgs;
import com.pulumi.gcp.compute.inputs.HealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
import com.pulumi.gcp.compute.inputs.URLMapTestArgs;
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 HealthCheck("default", HealthCheckArgs.builder()
            .httpHealthCheck(HealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
        var home = new BackendService("home", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(default_.id())
            .loadBalancingScheme("INTERNAL_SELF_MANAGED")
            .build());
        var urlmap = new URLMap("urlmap", URLMapArgs.builder()
            .description("a description")
            .defaultService(home.id())
            .hostRules(URLMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(URLMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(home.id())
                .routeRules(URLMapPathMatcherRouteRuleArgs.builder()
                    .priority(1)
                    .headerAction(URLMapPathMatcherRouteRuleHeaderActionArgs.builder()
                        .requestHeadersToRemoves("RemoveMe2")
                        .requestHeadersToAdds(URLMapPathMatcherRouteRuleHeaderActionRequestHeadersToAddArgs.builder()
                            .headerName("AddSomethingElse")
                            .headerValue("MyOtherValue")
                            .replace(true)
                            .build())
                        .responseHeadersToRemoves("RemoveMe3")
                        .responseHeadersToAdds(URLMapPathMatcherRouteRuleHeaderActionResponseHeadersToAddArgs.builder()
                            .headerName("AddMe")
                            .headerValue("MyValue")
                            .replace(false)
                            .build())
                        .build())
                    .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                        .fullPathMatch("a full path")
                        .headerMatches(URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs.builder()
                            .headerName("someheader")
                            .exactMatch("match this exactly")
                            .invertMatch(true)
                            .build())
                        .ignoreCase(true)
                        .metadataFilters(URLMapPathMatcherRouteRuleMatchRuleMetadataFilterArgs.builder()
                            .filterMatchCriteria("MATCH_ANY")
                            .filterLabels(URLMapPathMatcherRouteRuleMatchRuleMetadataFilterFilterLabelArgs.builder()
                                .name("PLANET")
                                .value("MARS")
                                .build())
                            .build())
                        .queryParameterMatches(URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                            .name("a query parameter")
                            .presentMatch(true)
                            .build())
                        .build())
                    .urlRedirect(URLMapPathMatcherRouteRuleUrlRedirectArgs.builder()
                        .hostRedirect("A host")
                        .httpsRedirect(false)
                        .pathRedirect("some/path")
                        .redirectResponseCode("TEMPORARY_REDIRECT")
                        .stripQuery(true)
                        .build())
                    .build())
                .build())
            .tests(URLMapTestArgs.builder()
                .service(home.id())
                .host("hi.com")
                .path("/home")
                .build())
            .build());
    }
}
Content copied to clipboard

Url Map Traffic Director Route Partial

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HealthCheck;
import com.pulumi.gcp.compute.HealthCheckArgs;
import com.pulumi.gcp.compute.inputs.HealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
import com.pulumi.gcp.compute.inputs.URLMapTestArgs;
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 HealthCheck("default", HealthCheckArgs.builder()
            .httpHealthCheck(HealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
        var home = new BackendService("home", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(default_.id())
            .loadBalancingScheme("INTERNAL_SELF_MANAGED")
            .build());
        var urlmap = new URLMap("urlmap", URLMapArgs.builder()
            .description("a description")
            .defaultService(home.id())
            .hostRules(URLMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(URLMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(home.id())
                .routeRules(URLMapPathMatcherRouteRuleArgs.builder()
                    .priority(1)
                    .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                        .prefixMatch("/someprefix")
                        .headerMatches(URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs.builder()
                            .headerName("someheader")
                            .exactMatch("match this exactly")
                            .invertMatch(true)
                            .build())
                        .build())
                    .urlRedirect(URLMapPathMatcherRouteRuleUrlRedirectArgs.builder()
                        .pathRedirect("some/path")
                        .redirectResponseCode("TEMPORARY_REDIRECT")
                        .build())
                    .build())
                .build())
            .tests(URLMapTestArgs.builder()
                .service(home.id())
                .host("hi.com")
                .path("/home")
                .build())
            .build());
    }
}
Content copied to clipboard

Url Map Traffic Director Path

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HealthCheck;
import com.pulumi.gcp.compute.HealthCheckArgs;
import com.pulumi.gcp.compute.inputs.HealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
import com.pulumi.gcp.compute.inputs.URLMapTestArgs;
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 HealthCheck("default", HealthCheckArgs.builder()
            .httpHealthCheck(HealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
        var home = new BackendService("home", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(default_.id())
            .loadBalancingScheme("INTERNAL_SELF_MANAGED")
            .build());
        var urlmap = new URLMap("urlmap", URLMapArgs.builder()
            .description("a description")
            .defaultService(home.id())
            .hostRules(URLMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(URLMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(home.id())
                .pathRules(URLMapPathMatcherPathRuleArgs.builder()
                    .paths("/home")
                    .routeAction(URLMapPathMatcherPathRuleRouteActionArgs.builder()
                        .corsPolicy(URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs.builder()
                            .allowCredentials(true)
                            .allowHeaders("Allowed content")
                            .allowMethods("GET")
                            .allowOriginRegexes("abc.*")
                            .allowOrigins("Allowed origin")
                            .exposeHeaders("Exposed header")
                            .maxAge(30)
                            .disabled(false)
                            .build())
                        .faultInjectionPolicy(URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyArgs.builder()
                            .abort(URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyAbortArgs.builder()
                                .httpStatus(234)
                                .percentage(5.6)
                                .build())
                            .delay(URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayArgs.builder()
                                .fixedDelay(URLMapPathMatcherPathRuleRouteActionFaultInjectionPolicyDelayFixedDelayArgs.builder()
                                    .seconds(0)
                                    .nanos(50000)
                                    .build())
                                .percentage(7.8)
                                .build())
                            .build())
                        .requestMirrorPolicy(URLMapPathMatcherPathRuleRouteActionRequestMirrorPolicyArgs.builder()
                            .backendService(home.id())
                            .build())
                        .retryPolicy(URLMapPathMatcherPathRuleRouteActionRetryPolicyArgs.builder()
                            .numRetries(4)
                            .perTryTimeout(URLMapPathMatcherPathRuleRouteActionRetryPolicyPerTryTimeoutArgs.builder()
                                .seconds(30)
                                .build())
                            .retryConditions(
                                "5xx",
                                "deadline-exceeded")
                            .build())
                        .timeout(URLMapPathMatcherPathRuleRouteActionTimeoutArgs.builder()
                            .seconds(20)
                            .nanos(750000000)
                            .build())
                        .urlRewrite(URLMapPathMatcherPathRuleRouteActionUrlRewriteArgs.builder()
                            .hostRewrite("dev.example.com")
                            .pathPrefixRewrite("/v1/api/")
                            .build())
                        .weightedBackendServices(URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs.builder()
                            .backendService(home.id())
                            .weight(400)
                            .headerAction(URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                                .requestHeadersToRemoves("RemoveMe")
                                .requestHeadersToAdds(URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                                    .headerName("AddMe")
                                    .headerValue("MyValue")
                                    .replace(true)
                                    .build())
                                .responseHeadersToRemoves("RemoveMe")
                                .responseHeadersToAdds(URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                    .headerName("AddMe")
                                    .headerValue("MyValue")
                                    .replace(false)
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .build())
            .tests(URLMapTestArgs.builder()
                .service(home.id())
                .host("hi.com")
                .path("/home")
                .build())
            .build());
    }
}
Content copied to clipboard

Url Map Traffic Director Path Partial

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HealthCheck;
import com.pulumi.gcp.compute.HealthCheckArgs;
import com.pulumi.gcp.compute.inputs.HealthCheckHttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
import com.pulumi.gcp.compute.inputs.URLMapTestArgs;
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 HealthCheck("default", HealthCheckArgs.builder()
            .httpHealthCheck(HealthCheckHttpHealthCheckArgs.builder()
                .port(80)
                .build())
            .build());
        var home = new BackendService("home", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(default_.id())
            .loadBalancingScheme("INTERNAL_SELF_MANAGED")
            .build());
        var urlmap = new URLMap("urlmap", URLMapArgs.builder()
            .description("a description")
            .defaultService(home.id())
            .hostRules(URLMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(URLMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(home.id())
                .pathRules(URLMapPathMatcherPathRuleArgs.builder()
                    .paths("/home")
                    .routeAction(URLMapPathMatcherPathRuleRouteActionArgs.builder()
                        .corsPolicy(URLMapPathMatcherPathRuleRouteActionCorsPolicyArgs.builder()
                            .allowCredentials(true)
                            .allowHeaders("Allowed content")
                            .allowMethods("GET")
                            .allowOriginRegexes("abc.*")
                            .allowOrigins("Allowed origin")
                            .exposeHeaders("Exposed header")
                            .maxAge(30)
                            .disabled(false)
                            .build())
                        .weightedBackendServices(URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceArgs.builder()
                            .backendService(home.id())
                            .weight(400)
                            .headerAction(URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionArgs.builder()
                                .requestHeadersToRemoves("RemoveMe")
                                .requestHeadersToAdds(URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionRequestHeadersToAddArgs.builder()
                                    .headerName("AddMe")
                                    .headerValue("MyValue")
                                    .replace(true)
                                    .build())
                                .responseHeadersToRemoves("RemoveMe")
                                .responseHeadersToAdds(URLMapPathMatcherPathRuleRouteActionWeightedBackendServiceHeaderActionResponseHeadersToAddArgs.builder()
                                    .headerName("AddMe")
                                    .headerValue("MyValue")
                                    .replace(false)
                                    .build())
                                .build())
                            .build())
                        .build())
                    .build())
                .build())
            .tests(URLMapTestArgs.builder()
                .service(home.id())
                .host("hi.com")
                .path("/home")
                .build())
            .build());
    }
}
Content copied to clipboard

Url Map Header Based Routing

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HttpHealthCheck;
import com.pulumi.gcp.compute.HttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
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 defaultHttpHealthCheck = new HttpHealthCheck("defaultHttpHealthCheck", HttpHealthCheckArgs.builder()
            .requestPath("/")
            .checkIntervalSec(1)
            .timeoutSec(1)
            .build());
        var defaultBackendService = new BackendService("defaultBackendService", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(defaultHttpHealthCheck.id())
            .build());
        var service_a = new BackendService("service-a", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(defaultHttpHealthCheck.id())
            .build());
        var service_b = new BackendService("service-b", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(defaultHttpHealthCheck.id())
            .build());
        var urlmap = new URLMap("urlmap", URLMapArgs.builder()
            .description("header-based routing example")
            .defaultService(defaultBackendService.id())
            .hostRules(URLMapHostRuleArgs.builder()
                .hosts("*")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(URLMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(defaultBackendService.id())
                .routeRules(
                    URLMapPathMatcherRouteRuleArgs.builder()
                        .priority(1)
                        .service(service_a.id())
                        .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .prefixMatch("/")
                            .ignoreCase(true)
                            .headerMatches(URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs.builder()
                                .headerName("abtest")
                                .exactMatch("a")
                                .build())
                            .build())
                        .build(),
                    URLMapPathMatcherRouteRuleArgs.builder()
                        .priority(2)
                        .service(service_b.id())
                        .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .ignoreCase(true)
                            .prefixMatch("/")
                            .headerMatches(URLMapPathMatcherRouteRuleMatchRuleHeaderMatchArgs.builder()
                                .headerName("abtest")
                                .exactMatch("b")
                                .build())
                            .build())
                        .build())
                .build())
            .build());
    }
}
Content copied to clipboard

Url Map Parameter Based Routing

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HttpHealthCheck;
import com.pulumi.gcp.compute.HttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
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 defaultHttpHealthCheck = new HttpHealthCheck("defaultHttpHealthCheck", HttpHealthCheckArgs.builder()
            .requestPath("/")
            .checkIntervalSec(1)
            .timeoutSec(1)
            .build());
        var defaultBackendService = new BackendService("defaultBackendService", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(defaultHttpHealthCheck.id())
            .build());
        var service_a = new BackendService("service-a", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(defaultHttpHealthCheck.id())
            .build());
        var service_b = new BackendService("service-b", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .healthChecks(defaultHttpHealthCheck.id())
            .build());
        var urlmap = new URLMap("urlmap", URLMapArgs.builder()
            .description("parameter-based routing example")
            .defaultService(defaultBackendService.id())
            .hostRules(URLMapHostRuleArgs.builder()
                .hosts("*")
                .pathMatcher("allpaths")
                .build())
            .pathMatchers(URLMapPathMatcherArgs.builder()
                .name("allpaths")
                .defaultService(defaultBackendService.id())
                .routeRules(
                    URLMapPathMatcherRouteRuleArgs.builder()
                        .priority(1)
                        .service(service_a.id())
                        .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .prefixMatch("/")
                            .ignoreCase(true)
                            .queryParameterMatches(URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                                .name("abtest")
                                .exactMatch("a")
                                .build())
                            .build())
                        .build(),
                    URLMapPathMatcherRouteRuleArgs.builder()
                        .priority(2)
                        .service(service_b.id())
                        .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .ignoreCase(true)
                            .prefixMatch("/")
                            .queryParameterMatches(URLMapPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                                .name("abtest")
                                .exactMatch("b")
                                .build())
                            .build())
                        .build())
                .build())
            .build());
    }
}
Content copied to clipboard

Url Map Path Template Match

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.HttpHealthCheck;
import com.pulumi.gcp.compute.HttpHealthCheckArgs;
import com.pulumi.gcp.compute.BackendService;
import com.pulumi.gcp.compute.BackendServiceArgs;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.compute.BackendBucket;
import com.pulumi.gcp.compute.BackendBucketArgs;
import com.pulumi.gcp.compute.URLMap;
import com.pulumi.gcp.compute.URLMapArgs;
import com.pulumi.gcp.compute.inputs.URLMapHostRuleArgs;
import com.pulumi.gcp.compute.inputs.URLMapPathMatcherArgs;
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 HttpHealthCheck("default", HttpHealthCheckArgs.builder()
            .requestPath("/")
            .checkIntervalSec(1)
            .timeoutSec(1)
            .build());
        var cart_backend = new BackendService("cart-backend", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .loadBalancingScheme("EXTERNAL_MANAGED")
            .healthChecks(default_.id())
            .build());
        var user_backend = new BackendService("user-backend", BackendServiceArgs.builder()
            .portName("http")
            .protocol("HTTP")
            .timeoutSec(10)
            .loadBalancingScheme("EXTERNAL_MANAGED")
            .healthChecks(default_.id())
            .build());
        var staticBucket = new Bucket("staticBucket", BucketArgs.builder()
            .location("US")
            .build());
        var staticBackendBucket = new BackendBucket("staticBackendBucket", BackendBucketArgs.builder()
            .bucketName(staticBucket.name())
            .enableCdn(true)
            .build());
        var urlmap = new URLMap("urlmap", URLMapArgs.builder()
            .description("a description")
            .defaultService(staticBackendBucket.id())
            .hostRules(URLMapHostRuleArgs.builder()
                .hosts("mysite.com")
                .pathMatcher("mysite")
                .build())
            .pathMatchers(URLMapPathMatcherArgs.builder()
                .name("mysite")
                .defaultService(staticBackendBucket.id())
                .routeRules(
                    URLMapPathMatcherRouteRuleArgs.builder()
                        .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .pathTemplateMatch("/xyzwebservices/v2/xyz/users/{username=*}/carts/{cartid=**}")
                            .build())
                        .service(cart_backend.id())
                        .priority(1)
                        .routeAction(URLMapPathMatcherRouteRuleRouteActionArgs.builder()
                            .urlRewrite(URLMapPathMatcherRouteRuleRouteActionUrlRewriteArgs.builder()
                                .pathTemplateRewrite("/{username}-{cartid}/")
                                .build())
                            .build())
                        .build(),
                    URLMapPathMatcherRouteRuleArgs.builder()
                        .matchRules(URLMapPathMatcherRouteRuleMatchRuleArgs.builder()
                            .pathTemplateMatch("/xyzwebservices/v2/xyz/users/*/accountinfo/*")
                             .build())
                         .service(user_backend.id())
                         .priority(2)
                         .build())
                 .build())
             .build());
     }
 }
Content copied to clipboard

Import

UrlMap can be imported using any of these accepted formats

$ pulumi import gcp:compute/uRLMap:URLMap default projects/{{project}}/global/urlMaps/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/uRLMap:URLMap default {{project}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:compute/uRLMap:URLMap default {{name}}
Content copied to clipboard

//

Properties

Link copied to clipboard
val creationTimestamp: Output<String>

Creation timestamp in RFC3339 text format.

Link copied to clipboard
val defaultRouteAction: Output<URLMapDefaultRouteAction>?

defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend. If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService is set, defaultRouteAction cannot contain any weightedBackendServices. Only one of defaultRouteAction or defaultUrlRedirect must be set. Structure is documented below.

Link copied to clipboard
val defaultService: Output<String>?

The backend service or backend bucket to use when none of the given rules match.

Link copied to clipboard
val defaultUrlRedirect: Output<URLMapDefaultUrlRedirect>?

When none of the specified hostRules match, the request is redirected to a URL specified by defaultUrlRedirect. If defaultUrlRedirect is specified, defaultService or defaultRouteAction must not be set. Structure is documented below.

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

An optional description of this resource. Provide this property when you create the resource.

Link copied to clipboard
val fingerprint: Output<String>

Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking.

Link copied to clipboard
val headerAction: Output<URLMapHeaderAction>?

Specifies changes to request and response headers that need to take effect for the selected backendService. The headerAction specified here take effect after headerAction specified under pathMatcher. Structure is documented below.

Link copied to clipboard
val hostRules: Output<List<URLMapHostRule>>?

The list of HostRules to use against the URL. Structure is documented below.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val mapId: Output<Int>

The unique identifier for the resource.

Link copied to clipboard
val name: Output<String>

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

Link copied to clipboard
val pathMatchers: Output<List<URLMapPathMatcher>>?

The list of named PathMatchers to use against the URL. Structure is documented below.

Link copied to clipboard
val project: Output<String>

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

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val selfLink: Output<String>

The URI of the created resource.

Link copied to clipboard
val tests: Output<List<URLMapTest>>?

The list of expected URL mapping tests. Request to update this UrlMap will succeed only if all of the test cases pass. You can specify a maximum of 100 tests per UrlMap. Structure is documented below.

Link copied to clipboard
val urn: Output<String>