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

EdgeCacheOriginArgs

data class EdgeCacheOriginArgs(val awsV4Authentication: Output<EdgeCacheOriginAwsV4AuthenticationArgs>? = null, val description: Output<String>? = null, val failoverOrigin: Output<String>? = null, val flexShielding: Output<EdgeCacheOriginFlexShieldingArgs>? = null, val labels: Output<Map<String, String>>? = null, val maxAttempts: Output<Int>? = null, val name: Output<String>? = null, val originAddress: Output<String>? = null, val originOverrideAction: Output<EdgeCacheOriginOriginOverrideActionArgs>? = null, val originRedirect: Output<EdgeCacheOriginOriginRedirectArgs>? = null, val port: Output<Int>? = null, val project: Output<String>? = null, val protocol: Output<String>? = null, val retryConditions: Output<List<String>>? = null, val timeout: Output<EdgeCacheOriginTimeoutArgs>? = null) : ConvertibleToJava<EdgeCacheOriginArgs>

EdgeCacheOrigin represents a HTTP-reachable backend for an EdgeCacheService. To get more information about EdgeCacheOrigin, see:

Example Usage

Network Services Edge Cache Origin Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.networkservices.EdgeCacheOrigin("default", {
    name: "my-origin",
    originAddress: "gs://media-edge-default",
    description: "The default bucket for media edge test",
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.networkservices.EdgeCacheOrigin("default",
    name="my-origin",
    origin_address="gs://media-edge-default",
    description="The default bucket for media edge test")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.NetworkServices.EdgeCacheOrigin("default", new()
    {
        Name = "my-origin",
        OriginAddress = "gs://media-edge-default",
        Description = "The default bucket for media edge test",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networkservices"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkservices.NewEdgeCacheOrigin(ctx, "default", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("my-origin"),
			OriginAddress: pulumi.String("gs://media-edge-default"),
			Description:   pulumi.String("The default bucket for media edge test"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.networkservices.EdgeCacheOrigin;
import com.pulumi.gcp.networkservices.EdgeCacheOriginArgs;
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 EdgeCacheOrigin("default", EdgeCacheOriginArgs.builder()
            .name("my-origin")
            .originAddress("gs://media-edge-default")
            .description("The default bucket for media edge test")
            .build());
    }
}
Content copied to clipboard
resources:
  default:
    type: gcp:networkservices:EdgeCacheOrigin
    properties:
      name: my-origin
      originAddress: gs://media-edge-default
      description: The default bucket for media edge test
Content copied to clipboard

Network Services Edge Cache Origin Advanced

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const fallback = new gcp.networkservices.EdgeCacheOrigin("fallback", {
    name: "my-fallback",
    originAddress: "fallback.example.com",
    description: "The default bucket for media edge test",
    maxAttempts: 3,
    protocol: "HTTP",
    port: 80,
    retryConditions: [
        "CONNECT_FAILURE",
        "NOT_FOUND",
        "HTTP_5XX",
        "FORBIDDEN",
    ],
    timeout: {
        connectTimeout: "10s",
        maxAttemptsTimeout: "20s",
        responseTimeout: "60s",
        readTimeout: "5s",
    },
    originOverrideAction: {
        urlRewrite: {
            hostRewrite: "example.com",
        },
        headerAction: {
            requestHeadersToAdds: [{
                headerName: "x-header",
                headerValue: "value",
                replace: true,
            }],
        },
    },
    originRedirect: {
        redirectConditions: [
            "MOVED_PERMANENTLY",
            "FOUND",
            "SEE_OTHER",
            "TEMPORARY_REDIRECT",
            "PERMANENT_REDIRECT",
        ],
    },
});
const _default = new gcp.networkservices.EdgeCacheOrigin("default", {
    name: "my-origin",
    originAddress: "gs://media-edge-default",
    failoverOrigin: fallback.id,
    description: "The default bucket for media edge test",
    maxAttempts: 2,
    labels: {
        a: "b",
    },
    timeout: {
        connectTimeout: "10s",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
fallback = gcp.networkservices.EdgeCacheOrigin("fallback",
    name="my-fallback",
    origin_address="fallback.example.com",
    description="The default bucket for media edge test",
    max_attempts=3,
    protocol="HTTP",
    port=80,
    retry_conditions=[
        "CONNECT_FAILURE",
        "NOT_FOUND",
        "HTTP_5XX",
        "FORBIDDEN",
    ],
    timeout={
        "connect_timeout": "10s",
        "max_attempts_timeout": "20s",
        "response_timeout": "60s",
        "read_timeout": "5s",
    },
    origin_override_action={
        "url_rewrite": {
            "host_rewrite": "example.com",
        },
        "header_action": {
            "request_headers_to_adds": [{
                "header_name": "x-header",
                "header_value": "value",
                "replace": True,
            }],
        },
    },
    origin_redirect={
        "redirect_conditions": [
            "MOVED_PERMANENTLY",
            "FOUND",
            "SEE_OTHER",
            "TEMPORARY_REDIRECT",
            "PERMANENT_REDIRECT",
        ],
    })
default = gcp.networkservices.EdgeCacheOrigin("default",
    name="my-origin",
    origin_address="gs://media-edge-default",
    failover_origin=fallback.id,
    description="The default bucket for media edge test",
    max_attempts=2,
    labels={
        "a": "b",
    },
    timeout={
        "connect_timeout": "10s",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var fallback = new Gcp.NetworkServices.EdgeCacheOrigin("fallback", new()
    {
        Name = "my-fallback",
        OriginAddress = "fallback.example.com",
        Description = "The default bucket for media edge test",
        MaxAttempts = 3,
        Protocol = "HTTP",
        Port = 80,
        RetryConditions = new[]
        {
            "CONNECT_FAILURE",
            "NOT_FOUND",
            "HTTP_5XX",
            "FORBIDDEN",
        },
        Timeout = new Gcp.NetworkServices.Inputs.EdgeCacheOriginTimeoutArgs
        {
            ConnectTimeout = "10s",
            MaxAttemptsTimeout = "20s",
            ResponseTimeout = "60s",
            ReadTimeout = "5s",
        },
        OriginOverrideAction = new Gcp.NetworkServices.Inputs.EdgeCacheOriginOriginOverrideActionArgs
        {
            UrlRewrite = new Gcp.NetworkServices.Inputs.EdgeCacheOriginOriginOverrideActionUrlRewriteArgs
            {
                HostRewrite = "example.com",
            },
            HeaderAction = new Gcp.NetworkServices.Inputs.EdgeCacheOriginOriginOverrideActionHeaderActionArgs
            {
                RequestHeadersToAdds = new[]
                {
                    new Gcp.NetworkServices.Inputs.EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs
                    {
                        HeaderName = "x-header",
                        HeaderValue = "value",
                        Replace = true,
                    },
                },
            },
        },
        OriginRedirect = new Gcp.NetworkServices.Inputs.EdgeCacheOriginOriginRedirectArgs
        {
            RedirectConditions = new[]
            {
                "MOVED_PERMANENTLY",
                "FOUND",
                "SEE_OTHER",
                "TEMPORARY_REDIRECT",
                "PERMANENT_REDIRECT",
            },
        },
    });
    var @default = new Gcp.NetworkServices.EdgeCacheOrigin("default", new()
    {
        Name = "my-origin",
        OriginAddress = "gs://media-edge-default",
        FailoverOrigin = fallback.Id,
        Description = "The default bucket for media edge test",
        MaxAttempts = 2,
        Labels =
        {
            { "a", "b" },
        },
        Timeout = new Gcp.NetworkServices.Inputs.EdgeCacheOriginTimeoutArgs
        {
            ConnectTimeout = "10s",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networkservices"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fallback, err := networkservices.NewEdgeCacheOrigin(ctx, "fallback", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("my-fallback"),
			OriginAddress: pulumi.String("fallback.example.com"),
			Description:   pulumi.String("The default bucket for media edge test"),
			MaxAttempts:   pulumi.Int(3),
			Protocol:      pulumi.String("HTTP"),
			Port:          pulumi.Int(80),
			RetryConditions: pulumi.StringArray{
				pulumi.String("CONNECT_FAILURE"),
				pulumi.String("NOT_FOUND"),
				pulumi.String("HTTP_5XX"),
				pulumi.String("FORBIDDEN"),
			},
			Timeout: &networkservices.EdgeCacheOriginTimeoutArgs{
				ConnectTimeout:     pulumi.String("10s"),
				MaxAttemptsTimeout: pulumi.String("20s"),
				ResponseTimeout:    pulumi.String("60s"),
				ReadTimeout:        pulumi.String("5s"),
			},
			OriginOverrideAction: &networkservices.EdgeCacheOriginOriginOverrideActionArgs{
				UrlRewrite: &networkservices.EdgeCacheOriginOriginOverrideActionUrlRewriteArgs{
					HostRewrite: pulumi.String("example.com"),
				},
				HeaderAction: &networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionArgs{
					RequestHeadersToAdds: networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray{
						&networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs{
							HeaderName:  pulumi.String("x-header"),
							HeaderValue: pulumi.String("value"),
							Replace:     pulumi.Bool(true),
						},
					},
				},
			},
			OriginRedirect: &networkservices.EdgeCacheOriginOriginRedirectArgs{
				RedirectConditions: pulumi.StringArray{
					pulumi.String("MOVED_PERMANENTLY"),
					pulumi.String("FOUND"),
					pulumi.String("SEE_OTHER"),
					pulumi.String("TEMPORARY_REDIRECT"),
					pulumi.String("PERMANENT_REDIRECT"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheOrigin(ctx, "default", &networkservices.EdgeCacheOriginArgs{
			Name:           pulumi.String("my-origin"),
			OriginAddress:  pulumi.String("gs://media-edge-default"),
			FailoverOrigin: fallback.ID(),
			Description:    pulumi.String("The default bucket for media edge test"),
			MaxAttempts:    pulumi.Int(2),
			Labels: pulumi.StringMap{
				"a": pulumi.String("b"),
			},
			Timeout: &networkservices.EdgeCacheOriginTimeoutArgs{
				ConnectTimeout: pulumi.String("10s"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.networkservices.EdgeCacheOrigin;
import com.pulumi.gcp.networkservices.EdgeCacheOriginArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheOriginTimeoutArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheOriginOriginOverrideActionArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheOriginOriginOverrideActionUrlRewriteArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheOriginOriginOverrideActionHeaderActionArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheOriginOriginRedirectArgs;
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 fallback = new EdgeCacheOrigin("fallback", EdgeCacheOriginArgs.builder()
            .name("my-fallback")
            .originAddress("fallback.example.com")
            .description("The default bucket for media edge test")
            .maxAttempts(3)
            .protocol("HTTP")
            .port(80)
            .retryConditions(
                "CONNECT_FAILURE",
                "NOT_FOUND",
                "HTTP_5XX",
                "FORBIDDEN")
            .timeout(EdgeCacheOriginTimeoutArgs.builder()
                .connectTimeout("10s")
                .maxAttemptsTimeout("20s")
                .responseTimeout("60s")
                .readTimeout("5s")
                .build())
            .originOverrideAction(EdgeCacheOriginOriginOverrideActionArgs.builder()
                .urlRewrite(EdgeCacheOriginOriginOverrideActionUrlRewriteArgs.builder()
                    .hostRewrite("example.com")
                    .build())
                .headerAction(EdgeCacheOriginOriginOverrideActionHeaderActionArgs.builder()
                    .requestHeadersToAdds(EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs.builder()
                        .headerName("x-header")
                        .headerValue("value")
                        .replace(true)
                        .build())
                    .build())
                .build())
            .originRedirect(EdgeCacheOriginOriginRedirectArgs.builder()
                .redirectConditions(
                    "MOVED_PERMANENTLY",
                    "FOUND",
                    "SEE_OTHER",
                    "TEMPORARY_REDIRECT",
                    "PERMANENT_REDIRECT")
                .build())
            .build());
        var default_ = new EdgeCacheOrigin("default", EdgeCacheOriginArgs.builder()
            .name("my-origin")
            .originAddress("gs://media-edge-default")
            .failoverOrigin(fallback.id())
            .description("The default bucket for media edge test")
            .maxAttempts(2)
            .labels(Map.of("a", "b"))
            .timeout(EdgeCacheOriginTimeoutArgs.builder()
                .connectTimeout("10s")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  fallback:
    type: gcp:networkservices:EdgeCacheOrigin
    properties:
      name: my-fallback
      originAddress: fallback.example.com
      description: The default bucket for media edge test
      maxAttempts: 3
      protocol: HTTP
      port: 80
      retryConditions:
        - CONNECT_FAILURE
        - NOT_FOUND
        - HTTP_5XX
        - FORBIDDEN
      timeout:
        connectTimeout: 10s
        maxAttemptsTimeout: 20s
        responseTimeout: 60s
        readTimeout: 5s
      originOverrideAction:
        urlRewrite:
          hostRewrite: example.com
        headerAction:
          requestHeadersToAdds:
            - headerName: x-header
              headerValue: value
              replace: true
      originRedirect:
        redirectConditions:
          - MOVED_PERMANENTLY
          - FOUND
          - SEE_OTHER
          - TEMPORARY_REDIRECT
          - PERMANENT_REDIRECT
  default:
    type: gcp:networkservices:EdgeCacheOrigin
    properties:
      name: my-origin
      originAddress: gs://media-edge-default
      failoverOrigin: ${fallback.id}
      description: The default bucket for media edge test
      maxAttempts: 2
      labels:
        a: b
      timeout:
        connectTimeout: 10s
Content copied to clipboard

Network Services Edge Cache Origin V4auth

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const secret_basic = new gcp.secretmanager.Secret("secret-basic", {
    secretId: "secret-name",
    replication: {
        auto: {},
    },
});
const secret_version_basic = new gcp.secretmanager.SecretVersion("secret-version-basic", {
    secret: secret_basic.id,
    secretData: "secret-data",
});
const _default = new gcp.networkservices.EdgeCacheOrigin("default", {
    name: "my-origin",
    originAddress: "gs://media-edge-default",
    description: "The default bucket for V4 authentication",
    awsV4Authentication: {
        accessKeyId: "ACCESSKEYID",
        secretAccessKeyVersion: secret_version_basic.id,
        originRegion: "auto",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
secret_basic = gcp.secretmanager.Secret("secret-basic",
    secret_id="secret-name",
    replication={
        "auto": {},
    })
secret_version_basic = gcp.secretmanager.SecretVersion("secret-version-basic",
    secret=secret_basic.id,
    secret_data="secret-data")
default = gcp.networkservices.EdgeCacheOrigin("default",
    name="my-origin",
    origin_address="gs://media-edge-default",
    description="The default bucket for V4 authentication",
    aws_v4_authentication={
        "access_key_id": "ACCESSKEYID",
        "secret_access_key_version": secret_version_basic.id,
        "origin_region": "auto",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var secret_basic = new Gcp.SecretManager.Secret("secret-basic", new()
    {
        SecretId = "secret-name",
        Replication = new Gcp.SecretManager.Inputs.SecretReplicationArgs
        {
            Auto = null,
        },
    });
    var secret_version_basic = new Gcp.SecretManager.SecretVersion("secret-version-basic", new()
    {
        Secret = secret_basic.Id,
        SecretData = "secret-data",
    });
    var @default = new Gcp.NetworkServices.EdgeCacheOrigin("default", new()
    {
        Name = "my-origin",
        OriginAddress = "gs://media-edge-default",
        Description = "The default bucket for V4 authentication",
        AwsV4Authentication = new Gcp.NetworkServices.Inputs.EdgeCacheOriginAwsV4AuthenticationArgs
        {
            AccessKeyId = "ACCESSKEYID",
            SecretAccessKeyVersion = secret_version_basic.Id,
            OriginRegion = "auto",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/networkservices"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/secretmanager"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		secret_basic, err := secretmanager.NewSecret(ctx, "secret-basic", &secretmanager.SecretArgs{
			SecretId: pulumi.String("secret-name"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: &secretmanager.SecretReplicationAutoArgs{},
			},
		})
		if err != nil {
			return err
		}
		secret_version_basic, err := secretmanager.NewSecretVersion(ctx, "secret-version-basic", &secretmanager.SecretVersionArgs{
			Secret:     secret_basic.ID(),
			SecretData: pulumi.String("secret-data"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheOrigin(ctx, "default", &networkservices.EdgeCacheOriginArgs{
			Name:          pulumi.String("my-origin"),
			OriginAddress: pulumi.String("gs://media-edge-default"),
			Description:   pulumi.String("The default bucket for V4 authentication"),
			AwsV4Authentication: &networkservices.EdgeCacheOriginAwsV4AuthenticationArgs{
				AccessKeyId:            pulumi.String("ACCESSKEYID"),
				SecretAccessKeyVersion: secret_version_basic.ID(),
				OriginRegion:           pulumi.String("auto"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
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.EdgeCacheOrigin;
import com.pulumi.gcp.networkservices.EdgeCacheOriginArgs;
import com.pulumi.gcp.networkservices.inputs.EdgeCacheOriginAwsV4AuthenticationArgs;
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(SecretReplicationAutoArgs.builder()
                    .build())
                .build())
            .build());
        var secret_version_basic = new SecretVersion("secret-version-basic", SecretVersionArgs.builder()
            .secret(secret_basic.id())
            .secretData("secret-data")
            .build());
        var default_ = new EdgeCacheOrigin("default", EdgeCacheOriginArgs.builder()
            .name("my-origin")
            .originAddress("gs://media-edge-default")
            .description("The default bucket for V4 authentication")
            .awsV4Authentication(EdgeCacheOriginAwsV4AuthenticationArgs.builder()
                .accessKeyId("ACCESSKEYID")
                .secretAccessKeyVersion(secret_version_basic.id())
                .originRegion("auto")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  secret-basic:
    type: gcp:secretmanager:Secret
    properties:
      secretId: secret-name
      replication:
        auto: {}
  secret-version-basic:
    type: gcp:secretmanager:SecretVersion
    properties:
      secret: ${["secret-basic"].id}
      secretData: secret-data
  default:
    type: gcp:networkservices:EdgeCacheOrigin
    properties:
      name: my-origin
      originAddress: gs://media-edge-default
      description: The default bucket for V4 authentication
      awsV4Authentication:
        accessKeyId: ACCESSKEYID
        secretAccessKeyVersion: ${["secret-version-basic"].id}
        originRegion: auto
Content copied to clipboard

Import

EdgeCacheOrigin can be imported using any of these accepted formats:

  • projects/{{project}}/locations/global/edgeCacheOrigins/{{name}}

  • {{project}}/{{name}}

  • {{name}} When using the pulumi import command, EdgeCacheOrigin can be imported using one of the formats above. For example:

$ pulumi import gcp:networkservices/edgeCacheOrigin:EdgeCacheOrigin default projects/{{project}}/locations/global/edgeCacheOrigins/{{name}}
Content copied to clipboard
$ pulumi import gcp:networkservices/edgeCacheOrigin:EdgeCacheOrigin default {{project}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:networkservices/edgeCacheOrigin:EdgeCacheOrigin default {{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(awsV4Authentication: Output<EdgeCacheOriginAwsV4AuthenticationArgs>? = null, description: Output<String>? = null, failoverOrigin: Output<String>? = null, flexShielding: Output<EdgeCacheOriginFlexShieldingArgs>? = null, labels: Output<Map<String, String>>? = null, maxAttempts: Output<Int>? = null, name: Output<String>? = null, originAddress: Output<String>? = null, originOverrideAction: Output<EdgeCacheOriginOriginOverrideActionArgs>? = null, originRedirect: Output<EdgeCacheOriginOriginRedirectArgs>? = null, port: Output<Int>? = null, project: Output<String>? = null, protocol: Output<String>? = null, retryConditions: Output<List<String>>? = null, timeout: Output<EdgeCacheOriginTimeoutArgs>? = null)

Properties

Link copied to clipboard
val awsV4Authentication: Output<EdgeCacheOriginAwsV4AuthenticationArgs>? = null

Enable AWS Signature Version 4 origin authentication. Structure is documented below.

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

A human-readable description of the resource.

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

The Origin resource to try when the current origin cannot be reached. After maxAttempts is reached, the configured failoverOrigin will be used to fulfil the request. The value of timeout.maxAttemptsTimeout dictates the timeout across all origins. A reference to a Topic resource.

Link copied to clipboard
val flexShielding: Output<EdgeCacheOriginFlexShieldingArgs>? = null

The FlexShieldingOptions to be used for all routes to this origin. If not set, defaults to a global caching layer in front of the origin. Structure is documented below.

Link copied to clipboard
val labels: Output<Map<String, String>>? = null

Set of label tags associated with the EdgeCache resource. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

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

The maximum number of attempts to cache fill from this origin. Another attempt is made when a cache fill fails with one of the retryConditions. Once maxAttempts to this origin have failed the failoverOrigin will be used, if one is specified. That failoverOrigin may specify its own maxAttempts, retryConditions and failoverOrigin to control its own cache fill failures. The total number of allowed attempts to cache fill across this and failover origins is limited to four. The total time allowed for cache fill attempts across this and failover origins can be controlled with maxAttemptsTimeout. The last valid, non-retried response from all origins will be returned to the client. If no origin returns a valid response, an HTTP 502 will be returned to the client. Defaults to 1. Must be a value greater than 0 and less than 4.

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

Name of the resource; provided by the client when the resource is created. The name must be 1-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.

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

A fully qualified domain name (FQDN) or IP address reachable over the public Internet, or the address of a Google Cloud Storage bucket. This address will be used as the origin for cache requests - e.g. FQDN: media-backend.example.com, IPv4: 35.218.1.1, IPv6: 2607:f8b0:4012:809::200e, Cloud Storage: gs://bucketname When providing an FQDN (hostname), it must be publicly resolvable (e.g. via Google public DNS) and IP addresses must be publicly routable. It must not contain a protocol (e.g., https://) and it must not contain any slashes. If a Cloud Storage bucket is provided, it must be in the canonical "gs://bucketname" format. Other forms, such as "storage.googleapis.com", will be rejected.

Link copied to clipboard
val originOverrideAction: Output<EdgeCacheOriginOriginOverrideActionArgs>? = null

The override actions, including url rewrites and header additions, for requests that use this origin. Structure is documented below.

Link copied to clipboard
val originRedirect: Output<EdgeCacheOriginOriginRedirectArgs>? = null

Follow redirects from this origin. Structure is documented below.

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

The port to connect to the origin on. Defaults to port 443 for HTTP2 and HTTPS protocols, and port 80 for HTTP.

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

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

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

The protocol to use to connect to the configured origin. Defaults to HTTP2, and it is strongly recommended that users use HTTP2 for both security & performance. When using HTTP2 or HTTPS as the protocol, a valid, publicly-signed, unexpired TLS (SSL) certificate must be presented by the origin server. Possible values are: HTTP2, HTTPS, HTTP.

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

Specifies one or more retry conditions for the configured origin. If the failure mode during a connection attempt to the origin matches the configured retryCondition(s), the origin request will be retried up to maxAttempts times. The failoverOrigin, if configured, will then be used to satisfy the request. The default retryCondition is "CONNECT_FAILURE". retryConditions apply to this origin, and not subsequent failoverOrigin(s), which may specify their own retryConditions and maxAttempts. Valid values are:

Link copied to clipboard
val timeout: Output<EdgeCacheOriginTimeoutArgs>? = null

The connection and HTTP timeout configuration for this origin. Structure is documented below.

Functions

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