pulumi-gcp-kotlin/com.pulumi.gcp.networkservices.kotlin/EdgeCacheService

EdgeCacheService

class EdgeCacheService : KotlinCustomResource

EdgeCacheService defines the IP addresses, protocols, security policies, cache policies and routing configuration.

Warning: These resources require allow-listing to use, and are not openly available to all Cloud customers. Engage with your Cloud account team to discuss how to onboard.

Example Usage

Network Services Edge Cache Service Basic

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.networkservices.EdgeCacheOrigin;
import com.pulumi.gcp.networkservices.EdgeCacheOriginArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheOriginTimeoutArgs;
import com.pulumi.gcp.networkservices.EdgeCacheService;
import com.pulumi.gcp.networkservices.EdgeCacheServiceArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheServiceRoutingArgs;
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 dest = new Bucket("dest", BucketArgs.builder()
            .location("US")
            .forceDestroy(true)
            .build());
        var instanceEdgeCacheOrigin = new EdgeCacheOrigin("instanceEdgeCacheOrigin", EdgeCacheOriginArgs.builder()
            .originAddress(dest.url())
            .description("The default bucket for media edge test")
            .maxAttempts(2)
            .timeout(EdgeCacheOriginTimeoutArgs.builder()
                .connectTimeout("10s")
                .build())
            .build());
        var instanceEdgeCacheService = new EdgeCacheService("instanceEdgeCacheService", EdgeCacheServiceArgs.builder()
            .description("some description")
            .routing(EdgeCacheServiceRoutingArgs.builder()
                .hostRules(EdgeCacheServiceRoutingHostRuleArgs.builder()
                    .description("host rule description")
                    .hosts("sslcert.tf-test.club")
                    .pathMatcher("routes")
                    .build())
                .pathMatchers(EdgeCacheServiceRoutingPathMatcherArgs.builder()
                    .name("routes")
                    .routeRules(EdgeCacheServiceRoutingPathMatcherRouteRuleArgs.builder()
                        .description("a route rule to match against")
                        .priority(1)
                        .matchRules(EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs.builder()
                            .prefixMatch("/")
                            .build())
                        .origin(instanceEdgeCacheOrigin.name())
                        .routeAction(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs.builder()
                            .cdnPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs.builder()
                                .cacheMode("CACHE_ALL_STATIC")
                                .defaultTtl("3600s")
                                .build())
                            .build())
                        .headerAction(EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs.builder()
                            .responseHeaderToAdds(EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs.builder()
                                .headerName("x-cache-status")
                                .headerValue("{cdn_cache_status}")
                                .build())
                            .build())
                        .build())
                    .build())
                .build())
            .build());
    }
}

Network Services Edge Cache Service Advanced

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.networkservices.EdgeCacheOrigin;
import com.pulumi.gcp.networkservices.EdgeCacheOriginArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheOriginTimeoutArgs;
import com.pulumi.gcp.networkservices.EdgeCacheService;
import com.pulumi.gcp.networkservices.EdgeCacheServiceArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheServiceRoutingArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheServiceLogConfigArgs;
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 dest = new Bucket("dest", BucketArgs.builder()
            .location("US")
            .forceDestroy(true)
            .build());
        var google = new EdgeCacheOrigin("google", EdgeCacheOriginArgs.builder()
            .originAddress("google.com")
            .description("The default bucket for media edge test")
            .maxAttempts(2)
            .timeout(EdgeCacheOriginTimeoutArgs.builder()
                .connectTimeout("10s")
                .build())
            .build());
        var instanceEdgeCacheOrigin = new EdgeCacheOrigin("instanceEdgeCacheOrigin", EdgeCacheOriginArgs.builder()
            .originAddress(dest.url())
            .description("The default bucket for media edge test")
            .maxAttempts(2)
            .timeout(EdgeCacheOriginTimeoutArgs.builder()
                .connectTimeout("10s")
                .build())
            .build());
        var instanceEdgeCacheService = new EdgeCacheService("instanceEdgeCacheService", EdgeCacheServiceArgs.builder()
            .description("some description")
            .disableQuic(true)
            .disableHttp2(true)
            .labels(Map.of("a", "b"))
            .routing(EdgeCacheServiceRoutingArgs.builder()
                .hostRules(
                    EdgeCacheServiceRoutingHostRuleArgs.builder()
                        .description("host rule description")
                        .hosts("sslcert.tf-test.club")
                        .pathMatcher("routes")
                        .build(),
                    EdgeCacheServiceRoutingHostRuleArgs.builder()
                        .description("host rule2")
                        .hosts("sslcert.tf-test2.club")
                        .pathMatcher("routes")
                        .build(),
                    EdgeCacheServiceRoutingHostRuleArgs.builder()
                        .description("host rule3")
                        .hosts("sslcert.tf-test3.club")
                        .pathMatcher("routesAdvanced")
                        .build())
                .pathMatchers(
                    EdgeCacheServiceRoutingPathMatcherArgs.builder()
                        .name("routes")
                        .routeRules(EdgeCacheServiceRoutingPathMatcherRouteRuleArgs.builder()
                            .description("a route rule to match against")
                            .priority(1)
                            .matchRules(EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs.builder()
                                .prefixMatch("/")
                                .build())
                            .origin(instanceEdgeCacheOrigin.name())
                            .routeAction(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs.builder()
                                .cdnPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs.builder()
                                    .cacheMode("CACHE_ALL_STATIC")
                                    .defaultTtl("3600s")
                                    .build())
                                .build())
                            .headerAction(EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs.builder()
                                .responseHeaderToAdds(EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs.builder()
                                    .headerName("x-cache-status")
                                    .headerValue("{cdn_cache_status}")
                                    .build())
                                .build())
                            .build())
                        .build(),
                    EdgeCacheServiceRoutingPathMatcherArgs.builder()
                        .name("routesAdvanced")
                        .description("an advanced ruleset")
                        .routeRules(
                            EdgeCacheServiceRoutingPathMatcherRouteRuleArgs.builder()
                                .description("an advanced route rule to match against")
                                .priority(1)
                                .matchRules(
                                    EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs.builder()
                                        .prefixMatch("/potato/")
                                        .queryParameterMatches(
                                            EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                                                .name("debug")
                                                .presentMatch(true)
                                                .build(),
                                            EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs.builder()
                                                .name("state")
                                                .exactMatch("debug")
                                                .build())
                                        .build(),
                                    EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs.builder()
                                        .fullPathMatch("/apple")
                                        .build())
                                .headerAction(EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs.builder()
                                    .requestHeaderToAdds(
                                        EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs.builder()
                                            .headerName("debug")
                                            .headerValue("true")
                                            .replace(true)
                                            .build(),
                                        EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs.builder()
                                            .headerName("potato")
                                            .headerValue("plant")
                                            .build())
                                    .responseHeaderToAdds(EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs.builder()
                                        .headerName("potato")
                                        .headerValue("plant")
                                        .replace(true)
                                        .build())
                                    .requestHeaderToRemoves(EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs.builder()
                                        .headerName("prod")
                                        .build())
                                    .responseHeaderToRemoves(EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs.builder()
                                        .headerName("prod")
                                        .build())
                                    .build())
                                .origin(instanceEdgeCacheOrigin.name())
                                .routeAction(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs.builder()
                                    .cdnPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs.builder()
                                        .cacheMode("CACHE_ALL_STATIC")
                                        .defaultTtl("3800s")
                                        .clientTtl("3600s")
                                        .maxTtl("9000s")
                                        .cacheKeyPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs.builder()
                                            .includeProtocol(true)
                                            .excludeHost(true)
                                            .includedQueryParameters(
                                                "apple",
                                                "dev",
                                                "santa",
                                                "claus")
                                            .includedHeaderNames("banana")
                                            .includedCookieNames("orange")
                                            .build())
                                        .negativeCaching(true)
                                        .signedRequestMode("DISABLED")
                                        .negativeCachingPolicy(Map.of("500", "3000s"))
                                        .build())
                                    .urlRewrite(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs.builder()
                                        .pathPrefixRewrite("/dev")
                                        .hostRewrite("dev.club")
                                        .build())
                                    .corsPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs.builder()
                                        .maxAge("2500s")
                                        .allowCredentials(true)
                                        .allowOrigins("*")
                                        .allowMethods("GET")
                                        .allowHeaders("dev")
                                        .exposeHeaders("prod")
                                        .build())
                                    .build())
                                .build(),
                            EdgeCacheServiceRoutingPathMatcherRouteRuleArgs.builder()
                                .description("a second route rule to match against")
                                .priority(2)
                                .matchRules(EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs.builder()
                                    .fullPathMatch("/yay")
                                    .build())
                                .origin(instanceEdgeCacheOrigin.name())
                                .routeAction(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs.builder()
                                    .cdnPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs.builder()
                                        .cacheMode("CACHE_ALL_STATIC")
                                        .defaultTtl("3600s")
                                        .cacheKeyPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs.builder()
                                            .excludedQueryParameters("dev")
                                            .build())
                                        .build())
                                    .corsPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs.builder()
                                        .maxAge("3000s")
                                        .allowHeaders("dev")
                                        .disabled(true)
                                        .build())
                                    .build())
                                .build())
                        .build())
                .build())
            .logConfig(EdgeCacheServiceLogConfigArgs.builder()
                .enable(true)
                .sampleRate(0.01)
                .build())
            .build());
    }
}

Network Services Edge Cache Service Dual Token

package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.secretmanager.Secret;
import com.pulumi.gcp.secretmanager.SecretArgs;
import com.pulumi.gcp.secretmanager.inputs.SecretReplicationArgs;
import com.pulumi.gcp.secretmanager.inputs.SecretReplicationAutoArgs;
import com.pulumi.gcp.secretmanager.SecretVersion;
import com.pulumi.gcp.secretmanager.SecretVersionArgs;
import com.pulumi.gcp.networkservices.EdgeCacheKeyset;
import com.pulumi.gcp.networkservices.EdgeCacheKeysetArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheKeysetPublicKeyArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheKeysetValidationSharedKeyArgs;
import com.pulumi.gcp.networkservices.EdgeCacheOrigin;
import com.pulumi.gcp.networkservices.EdgeCacheOriginArgs;
import com.pulumi.gcp.networkservices.EdgeCacheService;
import com.pulumi.gcp.networkservices.EdgeCacheServiceArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheServiceRoutingArgs;
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 secret_basic = new Secret("secret-basic", SecretArgs.builder()
            .secretId("secret-name")
            .replication(SecretReplicationArgs.builder()
                .auto()
                .build())
            .build());
        var secret_version_basic = new SecretVersion("secret-version-basic", SecretVersionArgs.builder()
            .secret(secret_basic.id())
            .secretData("secret-data")
            .build());
        var keyset = new EdgeCacheKeyset("keyset", EdgeCacheKeysetArgs.builder()
            .description("The default keyset")
            .publicKeys(EdgeCacheKeysetPublicKeyArgs.builder()
                .id("my-public-key")
                .managed(true)
                .build())
            .validationSharedKeys(EdgeCacheKeysetValidationSharedKeyArgs.builder()
                .secretVersion(secret_version_basic.id())
                .build())
            .build());
        var instanceEdgeCacheOrigin = new EdgeCacheOrigin("instanceEdgeCacheOrigin", EdgeCacheOriginArgs.builder()
            .originAddress("gs://media-edge-default")
            .description("The default bucket for media edge test")
            .build());
        var instanceEdgeCacheService = new EdgeCacheService("instanceEdgeCacheService", EdgeCacheServiceArgs.builder()
            .description("some description")
            .routing(EdgeCacheServiceRoutingArgs.builder()
                .hostRules(EdgeCacheServiceRoutingHostRuleArgs.builder()
                    .description("host rule description")
                    .hosts("sslcert.tf-test.club")
                    .pathMatcher("routes")
                    .build())
                .pathMatchers(EdgeCacheServiceRoutingPathMatcherArgs.builder()
                    .name("routes")
                    .routeRules(
                        EdgeCacheServiceRoutingPathMatcherRouteRuleArgs.builder()
                            .description("a route rule to match against master playlist")
                            .priority(1)
                            .matchRules(EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs.builder()
                                .pathTemplateMatch("/master.m3u8")
                                .build())
                            .origin(instanceEdgeCacheOrigin.name())
                            .routeAction(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs.builder()
                                .cdnPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs.builder()
                                    .signedRequestMode("REQUIRE_TOKENS")
                                    .signedRequestKeyset(keyset.id())
                                    .signedTokenOptions(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs.builder()
                                        .tokenQueryParameter("edge-cache-token")
                                        .build())
                                    .signedRequestMaximumExpirationTtl("600s")
                                    .addSignatures(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs.builder()
                                        .actions("GENERATE_COOKIE")
                                        .keyset(keyset.id())
                                        .copiedParameters(
                                            "PathGlobs",
                                            "SessionID")
                                        .build())
                                    .build())
                                .build())
                            .build(),
                        EdgeCacheServiceRoutingPathMatcherRouteRuleArgs.builder()
                            .description("a route rule to match against all playlists")
                            .priority(2)
                            .matchRules(EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs.builder()
                                .pathTemplateMatch("/*.m3u8")
                                .build())
                            .origin(instanceEdgeCacheOrigin.name())
                            .routeAction(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs.builder()
                                .cdnPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs.builder()
                                    .signedRequestMode("REQUIRE_TOKENS")
                                    .signedRequestKeyset(keyset.id())
                                    .signedTokenOptions(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs.builder()
                                        .tokenQueryParameter("hdnts")
                                        .allowedSignatureAlgorithms(
                                            "ED25519",
                                            "HMAC_SHA_256",
                                            "HMAC_SHA1")
                                        .build())
                                    .addSignatures(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs.builder()
                                        .actions("GENERATE_TOKEN_HLS_COOKIELESS")
                                        .keyset(keyset.id())
                                        .tokenTtl("1200s")
                                        .tokenQueryParameter("hdntl")
                                        .copiedParameters("URLPrefix")
                                        .build())
                                    .build())
                                .build())
                            .build(),
                        EdgeCacheServiceRoutingPathMatcherRouteRuleArgs.builder()
                            .description("a route rule to match against")
                            .priority(3)
                            .matchRules(EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs.builder()
                                .pathTemplateMatch("/**.m3u8")
                                .build())
                            .origin(instanceEdgeCacheOrigin.name())
                            .routeAction(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs.builder()
                                .cdnPolicy(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs.builder()
                                    .signedRequestMode("REQUIRE_TOKENS")
                                    .signedRequestKeyset(keyset.id())
                                    .signedTokenOptions(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs.builder()
                                        .tokenQueryParameter("hdntl")
                                        .build())
                                    .addSignatures(EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs.builder()
                                        .actions("PROPAGATE_TOKEN_HLS_COOKIELESS")
                                        .tokenQueryParameter("hdntl")
                                        .build())
                                    .build())
                                .build())
                            .build())
                    .build())
                .build())
            .build());
    }
}

Import

EdgeCacheService can be imported using any of these accepted formats

$ pulumi import gcp:networkservices/edgeCacheService:EdgeCacheService default projects/{{project}}/locations/global/edgeCacheServices/{{name}}

$ pulumi import gcp:networkservices/edgeCacheService:EdgeCacheService default {{project}}/{{name}}

$ pulumi import gcp:networkservices/edgeCacheService:EdgeCacheService default {{name}}

Properties

description

val description: Output<String>?

A human-readable description of the hostRule. (Optional) A human-readable description of the resource. (Optional) A human-readable description of the routeRule. (Optional) A human-readable description of the resource.

disableHttp2

val disableHttp2: Output<Boolean>?

Disables HTTP/2. HTTP/2 (h2) is enabled by default and recommended for performance. HTTP/2 improves connection re-use and reduces connection setup overhead by sending multiple streams over the same connection. Some legacy HTTP clients may have issues with HTTP/2 connections due to broken HTTP/2 implementations. Setting this to true will prevent HTTP/2 from being advertised and negotiated.

disableQuic

val disableQuic: Output<Boolean>

HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.

edgeSecurityPolicy

val edgeSecurityPolicy: Output<String>?

Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.

edgeSslCertificates

val edgeSslCertificates: Output<List<String>>?

URLs to sslCertificate resources that are used to authenticate connections between users and the EdgeCacheService. Note that only "global" certificates with a "scope" of "EDGE_CACHE" can be attached to an EdgeCacheService.

val id: Output<String>

ipv4Addresses

val ipv4Addresses: Output<List<String>>

The IPv4 addresses associated with this service. Addresses are static for the lifetime of the service.

ipv6Addresses

val ipv6Addresses: Output<List<String>>

The IPv6 addresses associated with this service. Addresses are static for the lifetime of the service.

labels

val labels: Output<Map<String, String>>?

Set of label tags associated with the EdgeCache resource.

logConfig

val logConfig: Output<EdgeCacheServiceLogConfig>?

Specifies the logging options for the traffic served by this service. If logging is enabled, logs will be exported to Cloud Logging. Structure is documented below.

name

val name: Output<String>

Name of the resource; provided by the client when the resource is created. The name must be 1-64 characters long, and match the regular expression a-zA-Z0-9_-* which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.

project

val project: Output<String>

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

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

requireTls

val requireTls: Output<Boolean>

Require TLS (HTTPS) for all clients connecting to this service. Clients who connect over HTTP (port 80) will receive a HTTP 301 to the same URL over HTTPS (port 443). You must have at least one (1) edgeSslCertificate specified to enable this.

routing

val routing: Output<EdgeCacheServiceRouting>

Defines how requests are routed, modified, cached and/or which origin content is filled from. Structure is documented below.

sslPolicy

val sslPolicy: Output<String>?

URL of the SslPolicy resource that will be associated with the EdgeCacheService. If not set, the EdgeCacheService has no SSL policy configured, and will default to the "COMPATIBLE" policy.

urn

val urn: Output<String>