networkservices

package
v6.42.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 7, 2022 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type EdgeCacheKeyset 

type EdgeCacheKeyset struct {
	pulumi.CustomResourceState

	// A human-readable description of the resource.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// 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-Z][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.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// An ordered list of Ed25519 public keys to use for validating signed requests.
	// You must specify at least one (1) key, and may have up to three (3) keys.
	// Ed25519 public keys are not secret, and only allow Google to validate a request was signed by your corresponding private key.
	// You should ensure that the private key is kept secret, and that only authorized users can add public keys to a keyset.
	// Structure is documented below.
	PublicKeys EdgeCacheKeysetPublicKeyArrayOutput `pulumi:"publicKeys"`
}

## Example Usage ### Network Services Edge Cache Keyset Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/networkservices"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networkservices.NewEdgeCacheKeyset(ctx, "default", &networkservices.EdgeCacheKeysetArgs{
			Description: pulumi.String("The default keyset"),
			PublicKeys: networkservices.EdgeCacheKeysetPublicKeyArray{
				&networkservices.EdgeCacheKeysetPublicKeyArgs{
					Id:    pulumi.String("my-public-key"),
					Value: pulumi.String("FHsTyFHNmvNpw4o7-rp-M1yqMyBF8vXSBRkZtkQ0RKY"),
				},
				&networkservices.EdgeCacheKeysetPublicKeyArgs{
					Id:    pulumi.String("my-public-key-2"),
					Value: pulumi.String("hzd03llxB1u5FOLKFkZ6_wCJqC7jtN0bg7xlBqS6WVM"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EdgeCacheKeyset can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/edgeCacheKeyset:EdgeCacheKeyset default projects/{{project}}/locations/global/edgeCacheKeysets/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/edgeCacheKeyset:EdgeCacheKeyset default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/edgeCacheKeyset:EdgeCacheKeyset default {{name}}

```

func GetEdgeCacheKeyset 

func GetEdgeCacheKeyset(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EdgeCacheKeysetState, opts ...pulumi.ResourceOption) (*EdgeCacheKeyset, error)

GetEdgeCacheKeyset gets an existing EdgeCacheKeyset resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEdgeCacheKeyset 

func NewEdgeCacheKeyset(ctx *pulumi.Context,
	name string, args *EdgeCacheKeysetArgs, opts ...pulumi.ResourceOption) (*EdgeCacheKeyset, error)

NewEdgeCacheKeyset registers a new resource with the given unique name, arguments, and options.

func (*EdgeCacheKeyset) ElementType 

func (*EdgeCacheKeyset) ElementType() reflect.Type

func (*EdgeCacheKeyset) ToEdgeCacheKeysetOutput 

func (i *EdgeCacheKeyset) ToEdgeCacheKeysetOutput() EdgeCacheKeysetOutput

func (*EdgeCacheKeyset) ToEdgeCacheKeysetOutputWithContext 

func (i *EdgeCacheKeyset) ToEdgeCacheKeysetOutputWithContext(ctx context.Context) EdgeCacheKeysetOutput

type EdgeCacheKeysetArgs 

type EdgeCacheKeysetArgs struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapInput
	// 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-Z][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.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// An ordered list of Ed25519 public keys to use for validating signed requests.
	// You must specify at least one (1) key, and may have up to three (3) keys.
	// Ed25519 public keys are not secret, and only allow Google to validate a request was signed by your corresponding private key.
	// You should ensure that the private key is kept secret, and that only authorized users can add public keys to a keyset.
	// Structure is documented below.
	PublicKeys EdgeCacheKeysetPublicKeyArrayInput
}

The set of arguments for constructing a EdgeCacheKeyset resource.

func (EdgeCacheKeysetArgs) ElementType 

func (EdgeCacheKeysetArgs) ElementType() reflect.Type

type EdgeCacheKeysetArray 

type EdgeCacheKeysetArray []EdgeCacheKeysetInput

func (EdgeCacheKeysetArray) ElementType 

func (EdgeCacheKeysetArray) ElementType() reflect.Type

func (EdgeCacheKeysetArray) ToEdgeCacheKeysetArrayOutput 

func (i EdgeCacheKeysetArray) ToEdgeCacheKeysetArrayOutput() EdgeCacheKeysetArrayOutput

func (EdgeCacheKeysetArray) ToEdgeCacheKeysetArrayOutputWithContext 

func (i EdgeCacheKeysetArray) ToEdgeCacheKeysetArrayOutputWithContext(ctx context.Context) EdgeCacheKeysetArrayOutput

type EdgeCacheKeysetArrayInput 

type EdgeCacheKeysetArrayInput interface {
	pulumi.Input

	ToEdgeCacheKeysetArrayOutput() EdgeCacheKeysetArrayOutput
	ToEdgeCacheKeysetArrayOutputWithContext(context.Context) EdgeCacheKeysetArrayOutput
}

EdgeCacheKeysetArrayInput is an input type that accepts EdgeCacheKeysetArray and EdgeCacheKeysetArrayOutput values. You can construct a concrete instance of `EdgeCacheKeysetArrayInput` via: 

EdgeCacheKeysetArray{ EdgeCacheKeysetArgs{...} }

type EdgeCacheKeysetArrayOutput 

type EdgeCacheKeysetArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetArrayOutput) ElementType 

func (EdgeCacheKeysetArrayOutput) ElementType() reflect.Type

func (EdgeCacheKeysetArrayOutput) Index 

func (o EdgeCacheKeysetArrayOutput) Index(i pulumi.IntInput) EdgeCacheKeysetOutput

func (EdgeCacheKeysetArrayOutput) ToEdgeCacheKeysetArrayOutput 

func (o EdgeCacheKeysetArrayOutput) ToEdgeCacheKeysetArrayOutput() EdgeCacheKeysetArrayOutput

func (EdgeCacheKeysetArrayOutput) ToEdgeCacheKeysetArrayOutputWithContext 

func (o EdgeCacheKeysetArrayOutput) ToEdgeCacheKeysetArrayOutputWithContext(ctx context.Context) EdgeCacheKeysetArrayOutput

type EdgeCacheKeysetInput 

type EdgeCacheKeysetInput interface {
	pulumi.Input

	ToEdgeCacheKeysetOutput() EdgeCacheKeysetOutput
	ToEdgeCacheKeysetOutputWithContext(ctx context.Context) EdgeCacheKeysetOutput
}

type EdgeCacheKeysetMap 

type EdgeCacheKeysetMap map[string]EdgeCacheKeysetInput

func (EdgeCacheKeysetMap) ElementType 

func (EdgeCacheKeysetMap) ElementType() reflect.Type

func (EdgeCacheKeysetMap) ToEdgeCacheKeysetMapOutput 

func (i EdgeCacheKeysetMap) ToEdgeCacheKeysetMapOutput() EdgeCacheKeysetMapOutput

func (EdgeCacheKeysetMap) ToEdgeCacheKeysetMapOutputWithContext 

func (i EdgeCacheKeysetMap) ToEdgeCacheKeysetMapOutputWithContext(ctx context.Context) EdgeCacheKeysetMapOutput

type EdgeCacheKeysetMapInput 

type EdgeCacheKeysetMapInput interface {
	pulumi.Input

	ToEdgeCacheKeysetMapOutput() EdgeCacheKeysetMapOutput
	ToEdgeCacheKeysetMapOutputWithContext(context.Context) EdgeCacheKeysetMapOutput
}

EdgeCacheKeysetMapInput is an input type that accepts EdgeCacheKeysetMap and EdgeCacheKeysetMapOutput values. You can construct a concrete instance of `EdgeCacheKeysetMapInput` via: 

EdgeCacheKeysetMap{ "key": EdgeCacheKeysetArgs{...} }

type EdgeCacheKeysetMapOutput 

type EdgeCacheKeysetMapOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetMapOutput) ElementType 

func (EdgeCacheKeysetMapOutput) ElementType() reflect.Type

func (EdgeCacheKeysetMapOutput) MapIndex 

func (o EdgeCacheKeysetMapOutput) MapIndex(k pulumi.StringInput) EdgeCacheKeysetOutput

func (EdgeCacheKeysetMapOutput) ToEdgeCacheKeysetMapOutput 

func (o EdgeCacheKeysetMapOutput) ToEdgeCacheKeysetMapOutput() EdgeCacheKeysetMapOutput

func (EdgeCacheKeysetMapOutput) ToEdgeCacheKeysetMapOutputWithContext 

func (o EdgeCacheKeysetMapOutput) ToEdgeCacheKeysetMapOutputWithContext(ctx context.Context) EdgeCacheKeysetMapOutput

type EdgeCacheKeysetOutput 

type EdgeCacheKeysetOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetOutput) Description added in v6.23.0 

func (o EdgeCacheKeysetOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheKeysetOutput) ElementType 

func (EdgeCacheKeysetOutput) ElementType() reflect.Type

func (EdgeCacheKeysetOutput) Labels added in v6.23.0 

func (o EdgeCacheKeysetOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the EdgeCache resource.

func (EdgeCacheKeysetOutput) Name added in v6.23.0 

func (o EdgeCacheKeysetOutput) Name() pulumi.StringOutput

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-Z][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.

func (EdgeCacheKeysetOutput) Project added in v6.23.0 

func (o EdgeCacheKeysetOutput) Project() pulumi.StringOutput

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

func (EdgeCacheKeysetOutput) PublicKeys added in v6.23.0 

func (o EdgeCacheKeysetOutput) PublicKeys() EdgeCacheKeysetPublicKeyArrayOutput

An ordered list of Ed25519 public keys to use for validating signed requests. You must specify at least one (1) key, and may have up to three (3) keys. Ed25519 public keys are not secret, and only allow Google to validate a request was signed by your corresponding private key. You should ensure that the private key is kept secret, and that only authorized users can add public keys to a keyset. Structure is documented below.

func (EdgeCacheKeysetOutput) ToEdgeCacheKeysetOutput 

func (o EdgeCacheKeysetOutput) ToEdgeCacheKeysetOutput() EdgeCacheKeysetOutput

func (EdgeCacheKeysetOutput) ToEdgeCacheKeysetOutputWithContext 

func (o EdgeCacheKeysetOutput) ToEdgeCacheKeysetOutputWithContext(ctx context.Context) EdgeCacheKeysetOutput

type EdgeCacheKeysetPublicKey 

type EdgeCacheKeysetPublicKey struct {
	// The ID of the public key. The ID must be 1-63 characters long, and comply with RFC1035.
	// The name must be 1-64 characters long, and match the regular expression [a-zA-Z][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.
	Id string `pulumi:"id"`
	// The base64-encoded value of the Ed25519 public key. The base64 encoding can be padded (44 bytes) or unpadded (43 bytes).
	// Representations or encodings of the public key other than this will be rejected with an error.
	// **Note**: This property is sensitive and will not be displayed in the plan.
	Value string `pulumi:"value"`
}

type EdgeCacheKeysetPublicKeyArgs 

type EdgeCacheKeysetPublicKeyArgs struct {
	// The ID of the public key. The ID must be 1-63 characters long, and comply with RFC1035.
	// The name must be 1-64 characters long, and match the regular expression [a-zA-Z][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.
	Id pulumi.StringInput `pulumi:"id"`
	// The base64-encoded value of the Ed25519 public key. The base64 encoding can be padded (44 bytes) or unpadded (43 bytes).
	// Representations or encodings of the public key other than this will be rejected with an error.
	// **Note**: This property is sensitive and will not be displayed in the plan.
	Value pulumi.StringInput `pulumi:"value"`
}

func (EdgeCacheKeysetPublicKeyArgs) ElementType 

func (EdgeCacheKeysetPublicKeyArgs) ElementType() reflect.Type

func (EdgeCacheKeysetPublicKeyArgs) ToEdgeCacheKeysetPublicKeyOutput 

func (i EdgeCacheKeysetPublicKeyArgs) ToEdgeCacheKeysetPublicKeyOutput() EdgeCacheKeysetPublicKeyOutput

func (EdgeCacheKeysetPublicKeyArgs) ToEdgeCacheKeysetPublicKeyOutputWithContext 

func (i EdgeCacheKeysetPublicKeyArgs) ToEdgeCacheKeysetPublicKeyOutputWithContext(ctx context.Context) EdgeCacheKeysetPublicKeyOutput

type EdgeCacheKeysetPublicKeyArray 

type EdgeCacheKeysetPublicKeyArray []EdgeCacheKeysetPublicKeyInput

func (EdgeCacheKeysetPublicKeyArray) ElementType 

func (EdgeCacheKeysetPublicKeyArray) ElementType() reflect.Type

func (EdgeCacheKeysetPublicKeyArray) ToEdgeCacheKeysetPublicKeyArrayOutput 

func (i EdgeCacheKeysetPublicKeyArray) ToEdgeCacheKeysetPublicKeyArrayOutput() EdgeCacheKeysetPublicKeyArrayOutput

func (EdgeCacheKeysetPublicKeyArray) ToEdgeCacheKeysetPublicKeyArrayOutputWithContext 

func (i EdgeCacheKeysetPublicKeyArray) ToEdgeCacheKeysetPublicKeyArrayOutputWithContext(ctx context.Context) EdgeCacheKeysetPublicKeyArrayOutput

type EdgeCacheKeysetPublicKeyArrayInput 

type EdgeCacheKeysetPublicKeyArrayInput interface {
	pulumi.Input

	ToEdgeCacheKeysetPublicKeyArrayOutput() EdgeCacheKeysetPublicKeyArrayOutput
	ToEdgeCacheKeysetPublicKeyArrayOutputWithContext(context.Context) EdgeCacheKeysetPublicKeyArrayOutput
}

EdgeCacheKeysetPublicKeyArrayInput is an input type that accepts EdgeCacheKeysetPublicKeyArray and EdgeCacheKeysetPublicKeyArrayOutput values. You can construct a concrete instance of `EdgeCacheKeysetPublicKeyArrayInput` via: 

EdgeCacheKeysetPublicKeyArray{ EdgeCacheKeysetPublicKeyArgs{...} }

type EdgeCacheKeysetPublicKeyArrayOutput 

type EdgeCacheKeysetPublicKeyArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetPublicKeyArrayOutput) ElementType 

func (EdgeCacheKeysetPublicKeyArrayOutput) ElementType() reflect.Type

func (EdgeCacheKeysetPublicKeyArrayOutput) Index 

func (o EdgeCacheKeysetPublicKeyArrayOutput) Index(i pulumi.IntInput) EdgeCacheKeysetPublicKeyOutput

func (EdgeCacheKeysetPublicKeyArrayOutput) ToEdgeCacheKeysetPublicKeyArrayOutput 

func (o EdgeCacheKeysetPublicKeyArrayOutput) ToEdgeCacheKeysetPublicKeyArrayOutput() EdgeCacheKeysetPublicKeyArrayOutput

func (EdgeCacheKeysetPublicKeyArrayOutput) ToEdgeCacheKeysetPublicKeyArrayOutputWithContext 

func (o EdgeCacheKeysetPublicKeyArrayOutput) ToEdgeCacheKeysetPublicKeyArrayOutputWithContext(ctx context.Context) EdgeCacheKeysetPublicKeyArrayOutput

type EdgeCacheKeysetPublicKeyInput 

type EdgeCacheKeysetPublicKeyInput interface {
	pulumi.Input

	ToEdgeCacheKeysetPublicKeyOutput() EdgeCacheKeysetPublicKeyOutput
	ToEdgeCacheKeysetPublicKeyOutputWithContext(context.Context) EdgeCacheKeysetPublicKeyOutput
}

EdgeCacheKeysetPublicKeyInput is an input type that accepts EdgeCacheKeysetPublicKeyArgs and EdgeCacheKeysetPublicKeyOutput values. You can construct a concrete instance of `EdgeCacheKeysetPublicKeyInput` via: 

EdgeCacheKeysetPublicKeyArgs{...}

type EdgeCacheKeysetPublicKeyOutput 

type EdgeCacheKeysetPublicKeyOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetPublicKeyOutput) ElementType 

func (EdgeCacheKeysetPublicKeyOutput) ElementType() reflect.Type

func (EdgeCacheKeysetPublicKeyOutput) Id 

func (o EdgeCacheKeysetPublicKeyOutput) Id() pulumi.StringOutput

The ID of the public key. The ID must be 1-63 characters long, and comply with RFC1035. The name must be 1-64 characters long, and match the regular expression [a-zA-Z][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.

func (EdgeCacheKeysetPublicKeyOutput) ToEdgeCacheKeysetPublicKeyOutput 

func (o EdgeCacheKeysetPublicKeyOutput) ToEdgeCacheKeysetPublicKeyOutput() EdgeCacheKeysetPublicKeyOutput

func (EdgeCacheKeysetPublicKeyOutput) ToEdgeCacheKeysetPublicKeyOutputWithContext 

func (o EdgeCacheKeysetPublicKeyOutput) ToEdgeCacheKeysetPublicKeyOutputWithContext(ctx context.Context) EdgeCacheKeysetPublicKeyOutput

func (EdgeCacheKeysetPublicKeyOutput) Value 

func (o EdgeCacheKeysetPublicKeyOutput) Value() pulumi.StringOutput

The base64-encoded value of the Ed25519 public key. The base64 encoding can be padded (44 bytes) or unpadded (43 bytes). Representations or encodings of the public key other than this will be rejected with an error. **Note**: This property is sensitive and will not be displayed in the plan.

type EdgeCacheKeysetState 

type EdgeCacheKeysetState struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapInput
	// 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-Z][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.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// An ordered list of Ed25519 public keys to use for validating signed requests.
	// You must specify at least one (1) key, and may have up to three (3) keys.
	// Ed25519 public keys are not secret, and only allow Google to validate a request was signed by your corresponding private key.
	// You should ensure that the private key is kept secret, and that only authorized users can add public keys to a keyset.
	// Structure is documented below.
	PublicKeys EdgeCacheKeysetPublicKeyArrayInput
}

func (EdgeCacheKeysetState) ElementType 

func (EdgeCacheKeysetState) ElementType() reflect.Type

type EdgeCacheOrigin 

type EdgeCacheOrigin struct {
	pulumi.CustomResourceState

	// A human-readable description of the resource.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// 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.
	FailoverOrigin pulumi.StringPtrOutput `pulumi:"failoverOrigin"`
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// 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.
	MaxAttempts pulumi.IntPtrOutput `pulumi:"maxAttempts"`
	// 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-Z][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.
	Name pulumi.StringOutput `pulumi:"name"`
	// 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.
	OriginAddress pulumi.StringOutput `pulumi:"originAddress"`
	// The port to connect to the origin on.
	// Defaults to port 443 for HTTP2 and HTTPS protocols, and port 80 for HTTP.
	Port pulumi.IntOutput `pulumi:"port"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// 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`, and `HTTP`.
	Protocol pulumi.StringOutput `pulumi:"protocol"`
	// 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:
	// - CONNECT_FAILURE: Retry on failures connecting to origins, for example due to connection timeouts.
	// - HTTP_5XX: Retry if the origin responds with any 5xx response code, or if the origin does not respond at all, example: disconnects, reset, read timeout, connection failure, and refused streams.
	// - GATEWAY_ERROR: Similar to 5xx, but only applies to response codes 502, 503 or 504.
	// - RETRIABLE_4XX: Retry for retriable 4xx response codes, which include HTTP 409 (Conflict) and HTTP 429 (Too Many Requests)
	// - NOT_FOUND: Retry if the origin returns a HTTP 404 (Not Found). This can be useful when generating video content, and the segment is not available yet.
	// - FORBIDDEN: Retry if the origin returns a HTTP 403 (Forbidden).
	//   Each value may be one of `CONNECT_FAILURE`, `HTTP_5XX`, `GATEWAY_ERROR`, `RETRIABLE_4XX`, `NOT_FOUND`, and `FORBIDDEN`.
	RetryConditions pulumi.StringArrayOutput `pulumi:"retryConditions"`
	// The connection and HTTP timeout configuration for this origin.
	// Structure is documented below.
	Timeout EdgeCacheOriginTimeoutPtrOutput `pulumi:"timeout"`
}

EdgeCacheOrigin represents a HTTP-reachable backend for an EdgeCacheService.

## Example Usage ### Network Services Edge Cache Origin Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v6/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{
			Description:   pulumi.String("The default bucket for media edge test"),
			OriginAddress: pulumi.String("gs://media-edge-default"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Edge Cache Origin Advanced

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v6/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{
			OriginAddress: pulumi.String("gs://media-edge-fallback"),
			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"),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheOrigin(ctx, "default", &networkservices.EdgeCacheOriginArgs{
			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
	})
}

```

## Import

EdgeCacheOrigin can be imported using any of these accepted formats

```sh 

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

```

```sh 

$ pulumi import gcp:networkservices/edgeCacheOrigin:EdgeCacheOrigin default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/edgeCacheOrigin:EdgeCacheOrigin default {{name}}

```

func GetEdgeCacheOrigin 

func GetEdgeCacheOrigin(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EdgeCacheOriginState, opts ...pulumi.ResourceOption) (*EdgeCacheOrigin, error)

GetEdgeCacheOrigin gets an existing EdgeCacheOrigin resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEdgeCacheOrigin 

func NewEdgeCacheOrigin(ctx *pulumi.Context,
	name string, args *EdgeCacheOriginArgs, opts ...pulumi.ResourceOption) (*EdgeCacheOrigin, error)

NewEdgeCacheOrigin registers a new resource with the given unique name, arguments, and options.

func (*EdgeCacheOrigin) ElementType 

func (*EdgeCacheOrigin) ElementType() reflect.Type

func (*EdgeCacheOrigin) ToEdgeCacheOriginOutput 

func (i *EdgeCacheOrigin) ToEdgeCacheOriginOutput() EdgeCacheOriginOutput

func (*EdgeCacheOrigin) ToEdgeCacheOriginOutputWithContext 

func (i *EdgeCacheOrigin) ToEdgeCacheOriginOutputWithContext(ctx context.Context) EdgeCacheOriginOutput

type EdgeCacheOriginArgs 

type EdgeCacheOriginArgs struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput
	// 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.
	FailoverOrigin pulumi.StringPtrInput
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapInput
	// 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.
	MaxAttempts pulumi.IntPtrInput
	// 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-Z][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.
	Name pulumi.StringPtrInput
	// 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.
	OriginAddress pulumi.StringInput
	// The port to connect to the origin on.
	// Defaults to port 443 for HTTP2 and HTTPS protocols, and port 80 for HTTP.
	Port pulumi.IntPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// 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`, and `HTTP`.
	Protocol pulumi.StringPtrInput
	// 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:
	// - CONNECT_FAILURE: Retry on failures connecting to origins, for example due to connection timeouts.
	// - HTTP_5XX: Retry if the origin responds with any 5xx response code, or if the origin does not respond at all, example: disconnects, reset, read timeout, connection failure, and refused streams.
	// - GATEWAY_ERROR: Similar to 5xx, but only applies to response codes 502, 503 or 504.
	// - RETRIABLE_4XX: Retry for retriable 4xx response codes, which include HTTP 409 (Conflict) and HTTP 429 (Too Many Requests)
	// - NOT_FOUND: Retry if the origin returns a HTTP 404 (Not Found). This can be useful when generating video content, and the segment is not available yet.
	// - FORBIDDEN: Retry if the origin returns a HTTP 403 (Forbidden).
	//   Each value may be one of `CONNECT_FAILURE`, `HTTP_5XX`, `GATEWAY_ERROR`, `RETRIABLE_4XX`, `NOT_FOUND`, and `FORBIDDEN`.
	RetryConditions pulumi.StringArrayInput
	// The connection and HTTP timeout configuration for this origin.
	// Structure is documented below.
	Timeout EdgeCacheOriginTimeoutPtrInput
}

The set of arguments for constructing a EdgeCacheOrigin resource.

func (EdgeCacheOriginArgs) ElementType 

func (EdgeCacheOriginArgs) ElementType() reflect.Type

type EdgeCacheOriginArray 

type EdgeCacheOriginArray []EdgeCacheOriginInput

func (EdgeCacheOriginArray) ElementType 

func (EdgeCacheOriginArray) ElementType() reflect.Type

func (EdgeCacheOriginArray) ToEdgeCacheOriginArrayOutput 

func (i EdgeCacheOriginArray) ToEdgeCacheOriginArrayOutput() EdgeCacheOriginArrayOutput

func (EdgeCacheOriginArray) ToEdgeCacheOriginArrayOutputWithContext 

func (i EdgeCacheOriginArray) ToEdgeCacheOriginArrayOutputWithContext(ctx context.Context) EdgeCacheOriginArrayOutput

type EdgeCacheOriginArrayInput 

type EdgeCacheOriginArrayInput interface {
	pulumi.Input

	ToEdgeCacheOriginArrayOutput() EdgeCacheOriginArrayOutput
	ToEdgeCacheOriginArrayOutputWithContext(context.Context) EdgeCacheOriginArrayOutput
}

EdgeCacheOriginArrayInput is an input type that accepts EdgeCacheOriginArray and EdgeCacheOriginArrayOutput values. You can construct a concrete instance of `EdgeCacheOriginArrayInput` via: 

EdgeCacheOriginArray{ EdgeCacheOriginArgs{...} }

type EdgeCacheOriginArrayOutput 

type EdgeCacheOriginArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginArrayOutput) ElementType 

func (EdgeCacheOriginArrayOutput) ElementType() reflect.Type

func (EdgeCacheOriginArrayOutput) Index 

func (o EdgeCacheOriginArrayOutput) Index(i pulumi.IntInput) EdgeCacheOriginOutput

func (EdgeCacheOriginArrayOutput) ToEdgeCacheOriginArrayOutput 

func (o EdgeCacheOriginArrayOutput) ToEdgeCacheOriginArrayOutput() EdgeCacheOriginArrayOutput

func (EdgeCacheOriginArrayOutput) ToEdgeCacheOriginArrayOutputWithContext 

func (o EdgeCacheOriginArrayOutput) ToEdgeCacheOriginArrayOutputWithContext(ctx context.Context) EdgeCacheOriginArrayOutput

type EdgeCacheOriginInput 

type EdgeCacheOriginInput interface {
	pulumi.Input

	ToEdgeCacheOriginOutput() EdgeCacheOriginOutput
	ToEdgeCacheOriginOutputWithContext(ctx context.Context) EdgeCacheOriginOutput
}

type EdgeCacheOriginMap 

type EdgeCacheOriginMap map[string]EdgeCacheOriginInput

func (EdgeCacheOriginMap) ElementType 

func (EdgeCacheOriginMap) ElementType() reflect.Type

func (EdgeCacheOriginMap) ToEdgeCacheOriginMapOutput 

func (i EdgeCacheOriginMap) ToEdgeCacheOriginMapOutput() EdgeCacheOriginMapOutput

func (EdgeCacheOriginMap) ToEdgeCacheOriginMapOutputWithContext 

func (i EdgeCacheOriginMap) ToEdgeCacheOriginMapOutputWithContext(ctx context.Context) EdgeCacheOriginMapOutput

type EdgeCacheOriginMapInput 

type EdgeCacheOriginMapInput interface {
	pulumi.Input

	ToEdgeCacheOriginMapOutput() EdgeCacheOriginMapOutput
	ToEdgeCacheOriginMapOutputWithContext(context.Context) EdgeCacheOriginMapOutput
}

EdgeCacheOriginMapInput is an input type that accepts EdgeCacheOriginMap and EdgeCacheOriginMapOutput values. You can construct a concrete instance of `EdgeCacheOriginMapInput` via: 

EdgeCacheOriginMap{ "key": EdgeCacheOriginArgs{...} }

type EdgeCacheOriginMapOutput 

type EdgeCacheOriginMapOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginMapOutput) ElementType 

func (EdgeCacheOriginMapOutput) ElementType() reflect.Type

func (EdgeCacheOriginMapOutput) MapIndex 

func (o EdgeCacheOriginMapOutput) MapIndex(k pulumi.StringInput) EdgeCacheOriginOutput

func (EdgeCacheOriginMapOutput) ToEdgeCacheOriginMapOutput 

func (o EdgeCacheOriginMapOutput) ToEdgeCacheOriginMapOutput() EdgeCacheOriginMapOutput

func (EdgeCacheOriginMapOutput) ToEdgeCacheOriginMapOutputWithContext 

func (o EdgeCacheOriginMapOutput) ToEdgeCacheOriginMapOutputWithContext(ctx context.Context) EdgeCacheOriginMapOutput

type EdgeCacheOriginOutput 

type EdgeCacheOriginOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOutput) Description added in v6.23.0 

func (o EdgeCacheOriginOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheOriginOutput) ElementType 

func (EdgeCacheOriginOutput) ElementType() reflect.Type

func (EdgeCacheOriginOutput) FailoverOrigin added in v6.23.0 

func (o EdgeCacheOriginOutput) FailoverOrigin() pulumi.StringPtrOutput

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.

func (EdgeCacheOriginOutput) Labels added in v6.23.0 

func (o EdgeCacheOriginOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the EdgeCache resource.

func (EdgeCacheOriginOutput) MaxAttempts added in v6.23.0 

func (o EdgeCacheOriginOutput) MaxAttempts() pulumi.IntPtrOutput

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.

func (EdgeCacheOriginOutput) Name added in v6.23.0 

func (o EdgeCacheOriginOutput) Name() pulumi.StringOutput

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-Z][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.

func (EdgeCacheOriginOutput) OriginAddress added in v6.23.0 

func (o EdgeCacheOriginOutput) OriginAddress() pulumi.StringOutput

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.

func (EdgeCacheOriginOutput) Port added in v6.23.0 

func (o EdgeCacheOriginOutput) Port() pulumi.IntOutput

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

func (EdgeCacheOriginOutput) Project added in v6.23.0 

func (o EdgeCacheOriginOutput) Project() pulumi.StringOutput

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

func (EdgeCacheOriginOutput) Protocol added in v6.23.0 

func (o EdgeCacheOriginOutput) Protocol() pulumi.StringOutput

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`, and `HTTP`.

func (EdgeCacheOriginOutput) RetryConditions added in v6.23.0 

func (o EdgeCacheOriginOutput) RetryConditions() pulumi.StringArrayOutput

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:

  • CONNECT_FAILURE: Retry on failures connecting to origins, for example due to connection timeouts.
  • HTTP_5XX: Retry if the origin responds with any 5xx response code, or if the origin does not respond at all, example: disconnects, reset, read timeout, connection failure, and refused streams.
  • GATEWAY_ERROR: Similar to 5xx, but only applies to response codes 502, 503 or 504.
  • RETRIABLE_4XX: Retry for retriable 4xx response codes, which include HTTP 409 (Conflict) and HTTP 429 (Too Many Requests)
  • NOT_FOUND: Retry if the origin returns a HTTP 404 (Not Found). This can be useful when generating video content, and the segment is not available yet.
  • FORBIDDEN: Retry if the origin returns a HTTP 403 (Forbidden). Each value may be one of `CONNECT_FAILURE`, `HTTP_5XX`, `GATEWAY_ERROR`, `RETRIABLE_4XX`, `NOT_FOUND`, and `FORBIDDEN`.

func (EdgeCacheOriginOutput) Timeout added in v6.23.0 

func (o EdgeCacheOriginOutput) Timeout() EdgeCacheOriginTimeoutPtrOutput

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

func (EdgeCacheOriginOutput) ToEdgeCacheOriginOutput 

func (o EdgeCacheOriginOutput) ToEdgeCacheOriginOutput() EdgeCacheOriginOutput

func (EdgeCacheOriginOutput) ToEdgeCacheOriginOutputWithContext 

func (o EdgeCacheOriginOutput) ToEdgeCacheOriginOutputWithContext(ctx context.Context) EdgeCacheOriginOutput

type EdgeCacheOriginState 

type EdgeCacheOriginState struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput
	// 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.
	FailoverOrigin pulumi.StringPtrInput
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapInput
	// 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.
	MaxAttempts pulumi.IntPtrInput
	// 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-Z][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.
	Name pulumi.StringPtrInput
	// 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.
	OriginAddress pulumi.StringPtrInput
	// The port to connect to the origin on.
	// Defaults to port 443 for HTTP2 and HTTPS protocols, and port 80 for HTTP.
	Port pulumi.IntPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// 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`, and `HTTP`.
	Protocol pulumi.StringPtrInput
	// 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:
	// - CONNECT_FAILURE: Retry on failures connecting to origins, for example due to connection timeouts.
	// - HTTP_5XX: Retry if the origin responds with any 5xx response code, or if the origin does not respond at all, example: disconnects, reset, read timeout, connection failure, and refused streams.
	// - GATEWAY_ERROR: Similar to 5xx, but only applies to response codes 502, 503 or 504.
	// - RETRIABLE_4XX: Retry for retriable 4xx response codes, which include HTTP 409 (Conflict) and HTTP 429 (Too Many Requests)
	// - NOT_FOUND: Retry if the origin returns a HTTP 404 (Not Found). This can be useful when generating video content, and the segment is not available yet.
	// - FORBIDDEN: Retry if the origin returns a HTTP 403 (Forbidden).
	//   Each value may be one of `CONNECT_FAILURE`, `HTTP_5XX`, `GATEWAY_ERROR`, `RETRIABLE_4XX`, `NOT_FOUND`, and `FORBIDDEN`.
	RetryConditions pulumi.StringArrayInput
	// The connection and HTTP timeout configuration for this origin.
	// Structure is documented below.
	Timeout EdgeCacheOriginTimeoutPtrInput
}

func (EdgeCacheOriginState) ElementType 

func (EdgeCacheOriginState) ElementType() reflect.Type

type EdgeCacheOriginTimeout 

type EdgeCacheOriginTimeout struct {
	// The maximum duration to wait for a single origin connection to be established, including DNS lookup, TLS handshake and TCP/QUIC connection establishment.
	// Defaults to 5 seconds. The timeout must be a value between 1s and 15s.
	// The connectTimeout capped by the deadline set by the request's maxAttemptsTimeout.  The last connection attempt may have a smaller connectTimeout in order to adhere to the overall maxAttemptsTimeout.
	ConnectTimeout *string `pulumi:"connectTimeout"`
	// The maximum time across all connection attempts to the origin, including failover origins, before returning an error to the client. A HTTP 504 will be returned if the timeout is reached before a response is returned.
	// Defaults to 15 seconds. The timeout must be a value between 1s and 30s.
	// If a failoverOrigin is specified, the maxAttemptsTimeout of the first configured origin sets the deadline for all connection attempts across all failoverOrigins.
	MaxAttemptsTimeout *string `pulumi:"maxAttemptsTimeout"`
	// The maximum duration to wait between reads of a single HTTP connection/stream.
	// Defaults to 15 seconds.  The timeout must be a value between 1s and 30s.
	// The readTimeout is capped by the responseTimeout.  All reads of the HTTP connection/stream must be completed by the deadline set by the responseTimeout.
	// If the response headers have already been written to the connection, the response will be truncated and logged.
	ReadTimeout *string `pulumi:"readTimeout"`
	// The maximum duration to wait for the last byte of a response to arrive when reading from the HTTP connection/stream.
	// Defaults to 30 seconds. The timeout must be a value between 1s and 120s.
	// The responseTimeout starts after the connection has been established.
	// This also applies to HTTP Chunked Transfer Encoding responses, and/or when an open-ended Range request is made to the origin. Origins that take longer to write additional bytes to the response than the configured responseTimeout will result in an error being returned to the client.
	// If the response headers have already been written to the connection, the response will be truncated and logged.
	ResponseTimeout *string `pulumi:"responseTimeout"`
}

type EdgeCacheOriginTimeoutArgs 

type EdgeCacheOriginTimeoutArgs struct {
	// The maximum duration to wait for a single origin connection to be established, including DNS lookup, TLS handshake and TCP/QUIC connection establishment.
	// Defaults to 5 seconds. The timeout must be a value between 1s and 15s.
	// The connectTimeout capped by the deadline set by the request's maxAttemptsTimeout.  The last connection attempt may have a smaller connectTimeout in order to adhere to the overall maxAttemptsTimeout.
	ConnectTimeout pulumi.StringPtrInput `pulumi:"connectTimeout"`
	// The maximum time across all connection attempts to the origin, including failover origins, before returning an error to the client. A HTTP 504 will be returned if the timeout is reached before a response is returned.
	// Defaults to 15 seconds. The timeout must be a value between 1s and 30s.
	// If a failoverOrigin is specified, the maxAttemptsTimeout of the first configured origin sets the deadline for all connection attempts across all failoverOrigins.
	MaxAttemptsTimeout pulumi.StringPtrInput `pulumi:"maxAttemptsTimeout"`
	// The maximum duration to wait between reads of a single HTTP connection/stream.
	// Defaults to 15 seconds.  The timeout must be a value between 1s and 30s.
	// The readTimeout is capped by the responseTimeout.  All reads of the HTTP connection/stream must be completed by the deadline set by the responseTimeout.
	// If the response headers have already been written to the connection, the response will be truncated and logged.
	ReadTimeout pulumi.StringPtrInput `pulumi:"readTimeout"`
	// The maximum duration to wait for the last byte of a response to arrive when reading from the HTTP connection/stream.
	// Defaults to 30 seconds. The timeout must be a value between 1s and 120s.
	// The responseTimeout starts after the connection has been established.
	// This also applies to HTTP Chunked Transfer Encoding responses, and/or when an open-ended Range request is made to the origin. Origins that take longer to write additional bytes to the response than the configured responseTimeout will result in an error being returned to the client.
	// If the response headers have already been written to the connection, the response will be truncated and logged.
	ResponseTimeout pulumi.StringPtrInput `pulumi:"responseTimeout"`
}

func (EdgeCacheOriginTimeoutArgs) ElementType 

func (EdgeCacheOriginTimeoutArgs) ElementType() reflect.Type

func (EdgeCacheOriginTimeoutArgs) ToEdgeCacheOriginTimeoutOutput 

func (i EdgeCacheOriginTimeoutArgs) ToEdgeCacheOriginTimeoutOutput() EdgeCacheOriginTimeoutOutput

func (EdgeCacheOriginTimeoutArgs) ToEdgeCacheOriginTimeoutOutputWithContext 

func (i EdgeCacheOriginTimeoutArgs) ToEdgeCacheOriginTimeoutOutputWithContext(ctx context.Context) EdgeCacheOriginTimeoutOutput

func (EdgeCacheOriginTimeoutArgs) ToEdgeCacheOriginTimeoutPtrOutput 

func (i EdgeCacheOriginTimeoutArgs) ToEdgeCacheOriginTimeoutPtrOutput() EdgeCacheOriginTimeoutPtrOutput

func (EdgeCacheOriginTimeoutArgs) ToEdgeCacheOriginTimeoutPtrOutputWithContext 

func (i EdgeCacheOriginTimeoutArgs) ToEdgeCacheOriginTimeoutPtrOutputWithContext(ctx context.Context) EdgeCacheOriginTimeoutPtrOutput

type EdgeCacheOriginTimeoutInput 

type EdgeCacheOriginTimeoutInput interface {
	pulumi.Input

	ToEdgeCacheOriginTimeoutOutput() EdgeCacheOriginTimeoutOutput
	ToEdgeCacheOriginTimeoutOutputWithContext(context.Context) EdgeCacheOriginTimeoutOutput
}

EdgeCacheOriginTimeoutInput is an input type that accepts EdgeCacheOriginTimeoutArgs and EdgeCacheOriginTimeoutOutput values. You can construct a concrete instance of `EdgeCacheOriginTimeoutInput` via: 

EdgeCacheOriginTimeoutArgs{...}

type EdgeCacheOriginTimeoutOutput 

type EdgeCacheOriginTimeoutOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginTimeoutOutput) ConnectTimeout 

func (o EdgeCacheOriginTimeoutOutput) ConnectTimeout() pulumi.StringPtrOutput

The maximum duration to wait for a single origin connection to be established, including DNS lookup, TLS handshake and TCP/QUIC connection establishment. Defaults to 5 seconds. The timeout must be a value between 1s and 15s. The connectTimeout capped by the deadline set by the request's maxAttemptsTimeout. The last connection attempt may have a smaller connectTimeout in order to adhere to the overall maxAttemptsTimeout.

func (EdgeCacheOriginTimeoutOutput) ElementType 

func (EdgeCacheOriginTimeoutOutput) ElementType() reflect.Type

func (EdgeCacheOriginTimeoutOutput) MaxAttemptsTimeout 

func (o EdgeCacheOriginTimeoutOutput) MaxAttemptsTimeout() pulumi.StringPtrOutput

The maximum time across all connection attempts to the origin, including failover origins, before returning an error to the client. A HTTP 504 will be returned if the timeout is reached before a response is returned. Defaults to 15 seconds. The timeout must be a value between 1s and 30s. If a failoverOrigin is specified, the maxAttemptsTimeout of the first configured origin sets the deadline for all connection attempts across all failoverOrigins.

func (EdgeCacheOriginTimeoutOutput) ReadTimeout added in v6.17.0 

func (o EdgeCacheOriginTimeoutOutput) ReadTimeout() pulumi.StringPtrOutput

The maximum duration to wait between reads of a single HTTP connection/stream. Defaults to 15 seconds. The timeout must be a value between 1s and 30s. The readTimeout is capped by the responseTimeout. All reads of the HTTP connection/stream must be completed by the deadline set by the responseTimeout. If the response headers have already been written to the connection, the response will be truncated and logged.

func (EdgeCacheOriginTimeoutOutput) ResponseTimeout 

func (o EdgeCacheOriginTimeoutOutput) ResponseTimeout() pulumi.StringPtrOutput

The maximum duration to wait for the last byte of a response to arrive when reading from the HTTP connection/stream. Defaults to 30 seconds. The timeout must be a value between 1s and 120s. The responseTimeout starts after the connection has been established. This also applies to HTTP Chunked Transfer Encoding responses, and/or when an open-ended Range request is made to the origin. Origins that take longer to write additional bytes to the response than the configured responseTimeout will result in an error being returned to the client. If the response headers have already been written to the connection, the response will be truncated and logged.

func (EdgeCacheOriginTimeoutOutput) ToEdgeCacheOriginTimeoutOutput 

func (o EdgeCacheOriginTimeoutOutput) ToEdgeCacheOriginTimeoutOutput() EdgeCacheOriginTimeoutOutput

func (EdgeCacheOriginTimeoutOutput) ToEdgeCacheOriginTimeoutOutputWithContext 

func (o EdgeCacheOriginTimeoutOutput) ToEdgeCacheOriginTimeoutOutputWithContext(ctx context.Context) EdgeCacheOriginTimeoutOutput

func (EdgeCacheOriginTimeoutOutput) ToEdgeCacheOriginTimeoutPtrOutput 

func (o EdgeCacheOriginTimeoutOutput) ToEdgeCacheOriginTimeoutPtrOutput() EdgeCacheOriginTimeoutPtrOutput

func (EdgeCacheOriginTimeoutOutput) ToEdgeCacheOriginTimeoutPtrOutputWithContext 

func (o EdgeCacheOriginTimeoutOutput) ToEdgeCacheOriginTimeoutPtrOutputWithContext(ctx context.Context) EdgeCacheOriginTimeoutPtrOutput

type EdgeCacheOriginTimeoutPtrInput 

type EdgeCacheOriginTimeoutPtrInput interface {
	pulumi.Input

	ToEdgeCacheOriginTimeoutPtrOutput() EdgeCacheOriginTimeoutPtrOutput
	ToEdgeCacheOriginTimeoutPtrOutputWithContext(context.Context) EdgeCacheOriginTimeoutPtrOutput
}

EdgeCacheOriginTimeoutPtrInput is an input type that accepts EdgeCacheOriginTimeoutArgs, EdgeCacheOriginTimeoutPtr and EdgeCacheOriginTimeoutPtrOutput values. You can construct a concrete instance of `EdgeCacheOriginTimeoutPtrInput` via: 

        EdgeCacheOriginTimeoutArgs{...}

or:

        nil

func EdgeCacheOriginTimeoutPtr 

func EdgeCacheOriginTimeoutPtr(v *EdgeCacheOriginTimeoutArgs) EdgeCacheOriginTimeoutPtrInput

type EdgeCacheOriginTimeoutPtrOutput 

type EdgeCacheOriginTimeoutPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginTimeoutPtrOutput) ConnectTimeout 

func (o EdgeCacheOriginTimeoutPtrOutput) ConnectTimeout() pulumi.StringPtrOutput

The maximum duration to wait for a single origin connection to be established, including DNS lookup, TLS handshake and TCP/QUIC connection establishment. Defaults to 5 seconds. The timeout must be a value between 1s and 15s. The connectTimeout capped by the deadline set by the request's maxAttemptsTimeout. The last connection attempt may have a smaller connectTimeout in order to adhere to the overall maxAttemptsTimeout.

func (EdgeCacheOriginTimeoutPtrOutput) Elem 

func (o EdgeCacheOriginTimeoutPtrOutput) Elem() EdgeCacheOriginTimeoutOutput

func (EdgeCacheOriginTimeoutPtrOutput) ElementType 

func (EdgeCacheOriginTimeoutPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginTimeoutPtrOutput) MaxAttemptsTimeout 

func (o EdgeCacheOriginTimeoutPtrOutput) MaxAttemptsTimeout() pulumi.StringPtrOutput

The maximum time across all connection attempts to the origin, including failover origins, before returning an error to the client. A HTTP 504 will be returned if the timeout is reached before a response is returned. Defaults to 15 seconds. The timeout must be a value between 1s and 30s. If a failoverOrigin is specified, the maxAttemptsTimeout of the first configured origin sets the deadline for all connection attempts across all failoverOrigins.

func (EdgeCacheOriginTimeoutPtrOutput) ReadTimeout added in v6.17.0 

func (o EdgeCacheOriginTimeoutPtrOutput) ReadTimeout() pulumi.StringPtrOutput

The maximum duration to wait between reads of a single HTTP connection/stream. Defaults to 15 seconds. The timeout must be a value between 1s and 30s. The readTimeout is capped by the responseTimeout. All reads of the HTTP connection/stream must be completed by the deadline set by the responseTimeout. If the response headers have already been written to the connection, the response will be truncated and logged.

func (EdgeCacheOriginTimeoutPtrOutput) ResponseTimeout 

func (o EdgeCacheOriginTimeoutPtrOutput) ResponseTimeout() pulumi.StringPtrOutput

The maximum duration to wait for the last byte of a response to arrive when reading from the HTTP connection/stream. Defaults to 30 seconds. The timeout must be a value between 1s and 120s. The responseTimeout starts after the connection has been established. This also applies to HTTP Chunked Transfer Encoding responses, and/or when an open-ended Range request is made to the origin. Origins that take longer to write additional bytes to the response than the configured responseTimeout will result in an error being returned to the client. If the response headers have already been written to the connection, the response will be truncated and logged.

func (EdgeCacheOriginTimeoutPtrOutput) ToEdgeCacheOriginTimeoutPtrOutput 

func (o EdgeCacheOriginTimeoutPtrOutput) ToEdgeCacheOriginTimeoutPtrOutput() EdgeCacheOriginTimeoutPtrOutput

func (EdgeCacheOriginTimeoutPtrOutput) ToEdgeCacheOriginTimeoutPtrOutputWithContext 

func (o EdgeCacheOriginTimeoutPtrOutput) ToEdgeCacheOriginTimeoutPtrOutputWithContext(ctx context.Context) EdgeCacheOriginTimeoutPtrOutput

type EdgeCacheService 

type EdgeCacheService struct {
	pulumi.CustomResourceState

	// A human-readable description of the resource.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// 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.
	DisableHttp2 pulumi.BoolPtrOutput `pulumi:"disableHttp2"`
	// HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.
	DisableQuic pulumi.BoolOutput `pulumi:"disableQuic"`
	// Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
	EdgeSecurityPolicy pulumi.StringPtrOutput `pulumi:"edgeSecurityPolicy"`
	// 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.
	EdgeSslCertificates pulumi.StringArrayOutput `pulumi:"edgeSslCertificates"`
	// The IPv4 addresses associated with this service. Addresses are static for the lifetime of the service.
	Ipv4Addresses pulumi.StringArrayOutput `pulumi:"ipv4Addresses"`
	// The IPv6 addresses associated with this service. Addresses are static for the lifetime of the service.
	Ipv6Addresses pulumi.StringArrayOutput `pulumi:"ipv6Addresses"`
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// 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.
	LogConfig EdgeCacheServiceLogConfigPtrOutput `pulumi:"logConfig"`
	// The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// 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.
	RequireTls pulumi.BoolOutput `pulumi:"requireTls"`
	// Defines how requests are routed, modified, cached and/or which origin content is filled from.
	// Structure is documented below.
	Routing EdgeCacheServiceRoutingOutput `pulumi:"routing"`
	// 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.
	SslPolicy pulumi.StringPtrOutput `pulumi:"sslPolicy"`
}

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

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/networkservices"
"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/storage"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		dest, err := storage.NewBucket(ctx, "dest", &storage.BucketArgs{
			Location:     pulumi.String("US"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		instanceEdgeCacheOrigin, err := networkservices.NewEdgeCacheOrigin(ctx, "instanceEdgeCacheOrigin", &networkservices.EdgeCacheOriginArgs{
			OriginAddress: dest.Url,
			Description:   pulumi.String("The default bucket for media edge test"),
			MaxAttempts:   pulumi.Int(2),
			Timeout: &networkservices.EdgeCacheOriginTimeoutArgs{
				ConnectTimeout: pulumi.String("10s"),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheService(ctx, "instanceEdgeCacheService", &networkservices.EdgeCacheServiceArgs{
			Description: pulumi.String("some description"),
			Routing: &networkservices.EdgeCacheServiceRoutingArgs{
				HostRules: networkservices.EdgeCacheServiceRoutingHostRuleArray{
					&networkservices.EdgeCacheServiceRoutingHostRuleArgs{
						Description: pulumi.String("host rule description"),
						Hosts: pulumi.StringArray{
							pulumi.String("sslcert.tf-test.club"),
						},
						PathMatcher: pulumi.String("routes"),
					},
				},
				PathMatchers: networkservices.EdgeCacheServiceRoutingPathMatcherArray{
					&networkservices.EdgeCacheServiceRoutingPathMatcherArgs{
						Name: pulumi.String("routes"),
						RouteRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArray{
							&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArgs{
								Description: pulumi.String("a route rule to match against"),
								Priority:    pulumi.String("1"),
								MatchRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray{
									&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{
										PrefixMatch: pulumi.String("/"),
									},
								},
								Origin: instanceEdgeCacheOrigin.Name,
								RouteAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{
									CdnPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{
										CacheMode:  pulumi.String("CACHE_ALL_STATIC"),
										DefaultTtl: pulumi.String("3600s"),
									},
								},
								HeaderAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs{
									ResponseHeaderToAdds: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray{
										&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs{
											HeaderName:  pulumi.String("x-cache-status"),
											HeaderValue: pulumi.String("{cdn_cache_status}"),
										},
									},
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Edge Cache Service Advanced

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/networkservices"
"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/storage"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		dest, err := storage.NewBucket(ctx, "dest", &storage.BucketArgs{
			Location:     pulumi.String("US"),
			ForceDestroy: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheOrigin(ctx, "google", &networkservices.EdgeCacheOriginArgs{
			OriginAddress: pulumi.String("google.com"),
			Description:   pulumi.String("The default bucket for media edge test"),
			MaxAttempts:   pulumi.Int(2),
			Timeout: &networkservices.EdgeCacheOriginTimeoutArgs{
				ConnectTimeout: pulumi.String("10s"),
			},
		})
		if err != nil {
			return err
		}
		instanceEdgeCacheOrigin, err := networkservices.NewEdgeCacheOrigin(ctx, "instanceEdgeCacheOrigin", &networkservices.EdgeCacheOriginArgs{
			OriginAddress: dest.Url,
			Description:   pulumi.String("The default bucket for media edge test"),
			MaxAttempts:   pulumi.Int(2),
			Timeout: &networkservices.EdgeCacheOriginTimeoutArgs{
				ConnectTimeout: pulumi.String("10s"),
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheService(ctx, "instanceEdgeCacheService", &networkservices.EdgeCacheServiceArgs{
			Description:  pulumi.String("some description"),
			DisableQuic:  pulumi.Bool(true),
			DisableHttp2: pulumi.Bool(true),
			Labels: pulumi.StringMap{
				"a": pulumi.String("b"),
			},
			Routing: &networkservices.EdgeCacheServiceRoutingArgs{
				HostRules: networkservices.EdgeCacheServiceRoutingHostRuleArray{
					&networkservices.EdgeCacheServiceRoutingHostRuleArgs{
						Description: pulumi.String("host rule description"),
						Hosts: pulumi.StringArray{
							pulumi.String("sslcert.tf-test.club"),
						},
						PathMatcher: pulumi.String("routes"),
					},
					&networkservices.EdgeCacheServiceRoutingHostRuleArgs{
						Description: pulumi.String("host rule2"),
						Hosts: pulumi.StringArray{
							pulumi.String("sslcert.tf-test2.club"),
						},
						PathMatcher: pulumi.String("routes"),
					},
					&networkservices.EdgeCacheServiceRoutingHostRuleArgs{
						Description: pulumi.String("host rule3"),
						Hosts: pulumi.StringArray{
							pulumi.String("sslcert.tf-test3.club"),
						},
						PathMatcher: pulumi.String("routesAdvanced"),
					},
				},
				PathMatchers: networkservices.EdgeCacheServiceRoutingPathMatcherArray{
					&networkservices.EdgeCacheServiceRoutingPathMatcherArgs{
						Name: pulumi.String("routes"),
						RouteRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArray{
							&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArgs{
								Description: pulumi.String("a route rule to match against"),
								Priority:    pulumi.String("1"),
								MatchRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray{
									&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{
										PrefixMatch: pulumi.String("/"),
									},
								},
								Origin: instanceEdgeCacheOrigin.Name,
								RouteAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{
									CdnPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{
										CacheMode:  pulumi.String("CACHE_ALL_STATIC"),
										DefaultTtl: pulumi.String("3600s"),
									},
								},
								HeaderAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs{
									ResponseHeaderToAdds: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray{
										&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs{
											HeaderName:  pulumi.String("x-cache-status"),
											HeaderValue: pulumi.String("{cdn_cache_status}"),
										},
									},
								},
							},
						},
					},
					&networkservices.EdgeCacheServiceRoutingPathMatcherArgs{
						Name:        pulumi.String("routesAdvanced"),
						Description: pulumi.String("an advanced ruleset"),
						RouteRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArray{
							&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArgs{
								Description: pulumi.String("an advanced route rule to match against"),
								Priority:    pulumi.String("1"),
								MatchRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray{
									&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{
										PrefixMatch: pulumi.String("/potato/"),
										QueryParameterMatches: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray{
											&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs{
												Name:         pulumi.String("debug"),
												PresentMatch: pulumi.Bool(true),
											},
											&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs{
												Name:       pulumi.String("state"),
												ExactMatch: pulumi.String("debug"),
											},
										},
									},
									&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{
										FullPathMatch: pulumi.String("/apple"),
									},
								},
								HeaderAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs{
									RequestHeaderToAdds: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray{
										&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs{
											HeaderName:  pulumi.String("debug"),
											HeaderValue: pulumi.String("true"),
											Replace:     pulumi.Bool(true),
										},
										&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs{
											HeaderName:  pulumi.String("potato"),
											HeaderValue: pulumi.String("plant"),
										},
									},
									ResponseHeaderToAdds: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray{
										&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs{
											HeaderName:  pulumi.String("potato"),
											HeaderValue: pulumi.String("plant"),
											Replace:     pulumi.Bool(true),
										},
									},
									RequestHeaderToRemoves: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray{
										&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs{
											HeaderName: pulumi.String("prod"),
										},
									},
									ResponseHeaderToRemoves: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray{
										&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs{
											HeaderName: pulumi.String("prod"),
										},
									},
								},
								Origin: instanceEdgeCacheOrigin.Name,
								RouteAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{
									CdnPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{
										CacheMode:  pulumi.String("CACHE_ALL_STATIC"),
										DefaultTtl: pulumi.String("3800s"),
										ClientTtl:  pulumi.String("3600s"),
										MaxTtl:     pulumi.String("9000s"),
										CacheKeyPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs{
											IncludeProtocol: pulumi.Bool(true),
											ExcludeHost:     pulumi.Bool(true),
											IncludedQueryParameters: pulumi.StringArray{
												pulumi.String("apple"),
												pulumi.String("dev"),
												pulumi.String("santa"),
												pulumi.String("claus"),
											},
											IncludedHeaderNames: pulumi.StringArray{
												pulumi.String("banana"),
											},
											IncludedCookieNames: pulumi.StringArray{
												pulumi.String("orange"),
											},
										},
										NegativeCaching:   pulumi.Bool(true),
										SignedRequestMode: pulumi.String("DISABLED"),
										NegativeCachingPolicy: pulumi.StringMap{
											"500": pulumi.String("3000s"),
										},
									},
									UrlRewrite: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs{
										PathPrefixRewrite: pulumi.String("/dev"),
										HostRewrite:       pulumi.String("dev.club"),
									},
									CorsPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs{
										MaxAge:           pulumi.String("2500s"),
										AllowCredentials: pulumi.Bool(true),
										AllowOrigins: pulumi.StringArray{
											pulumi.String("*"),
										},
										AllowMethods: pulumi.StringArray{
											pulumi.String("GET"),
										},
										AllowHeaders: pulumi.StringArray{
											pulumi.String("dev"),
										},
										ExposeHeaders: pulumi.StringArray{
											pulumi.String("prod"),
										},
									},
								},
							},
							&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleArgs{
								Description: pulumi.String("a second route rule to match against"),
								Priority:    pulumi.String("2"),
								MatchRules: networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray{
									&networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{
										FullPathMatch: pulumi.String("/yay"),
									},
								},
								Origin: instanceEdgeCacheOrigin.Name,
								RouteAction: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{
									CdnPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{
										CacheMode:  pulumi.String("CACHE_ALL_STATIC"),
										DefaultTtl: pulumi.String("3600s"),
										CacheKeyPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs{
											ExcludedQueryParameters: pulumi.StringArray{
												pulumi.String("dev"),
											},
										},
									},
									CorsPolicy: &networkservices.EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs{
										MaxAge: pulumi.String("3000s"),
										AllowHeaders: pulumi.StringArray{
											pulumi.String("dev"),
										},
										Disabled: pulumi.Bool(true),
									},
								},
							},
						},
					},
				},
			},
			LogConfig: &networkservices.EdgeCacheServiceLogConfigArgs{
				Enable:     pulumi.Bool(true),
				SampleRate: pulumi.Float64(0.01),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EdgeCacheService can be imported using any of these accepted formats

```sh 

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

```

```sh 

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

```

```sh 

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

```

func GetEdgeCacheService 

func GetEdgeCacheService(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EdgeCacheServiceState, opts ...pulumi.ResourceOption) (*EdgeCacheService, error)

GetEdgeCacheService gets an existing EdgeCacheService resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewEdgeCacheService 

func NewEdgeCacheService(ctx *pulumi.Context,
	name string, args *EdgeCacheServiceArgs, opts ...pulumi.ResourceOption) (*EdgeCacheService, error)

NewEdgeCacheService registers a new resource with the given unique name, arguments, and options.

func (*EdgeCacheService) ElementType 

func (*EdgeCacheService) ElementType() reflect.Type

func (*EdgeCacheService) ToEdgeCacheServiceOutput 

func (i *EdgeCacheService) ToEdgeCacheServiceOutput() EdgeCacheServiceOutput

func (*EdgeCacheService) ToEdgeCacheServiceOutputWithContext 

func (i *EdgeCacheService) ToEdgeCacheServiceOutputWithContext(ctx context.Context) EdgeCacheServiceOutput

type EdgeCacheServiceArgs 

type EdgeCacheServiceArgs struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput
	// 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.
	DisableHttp2 pulumi.BoolPtrInput
	// HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.
	DisableQuic pulumi.BoolPtrInput
	// Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
	EdgeSecurityPolicy pulumi.StringPtrInput
	// 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.
	EdgeSslCertificates pulumi.StringArrayInput
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapInput
	// 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.
	LogConfig EdgeCacheServiceLogConfigPtrInput
	// The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// 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.
	RequireTls pulumi.BoolPtrInput
	// Defines how requests are routed, modified, cached and/or which origin content is filled from.
	// Structure is documented below.
	Routing EdgeCacheServiceRoutingInput
	// 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.
	SslPolicy pulumi.StringPtrInput
}

The set of arguments for constructing a EdgeCacheService resource.

func (EdgeCacheServiceArgs) ElementType 

func (EdgeCacheServiceArgs) ElementType() reflect.Type

type EdgeCacheServiceArray 

type EdgeCacheServiceArray []EdgeCacheServiceInput

func (EdgeCacheServiceArray) ElementType 

func (EdgeCacheServiceArray) ElementType() reflect.Type

func (EdgeCacheServiceArray) ToEdgeCacheServiceArrayOutput 

func (i EdgeCacheServiceArray) ToEdgeCacheServiceArrayOutput() EdgeCacheServiceArrayOutput

func (EdgeCacheServiceArray) ToEdgeCacheServiceArrayOutputWithContext 

func (i EdgeCacheServiceArray) ToEdgeCacheServiceArrayOutputWithContext(ctx context.Context) EdgeCacheServiceArrayOutput

type EdgeCacheServiceArrayInput 

type EdgeCacheServiceArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceArrayOutput() EdgeCacheServiceArrayOutput
	ToEdgeCacheServiceArrayOutputWithContext(context.Context) EdgeCacheServiceArrayOutput
}

EdgeCacheServiceArrayInput is an input type that accepts EdgeCacheServiceArray and EdgeCacheServiceArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceArrayInput` via: 

EdgeCacheServiceArray{ EdgeCacheServiceArgs{...} }

type EdgeCacheServiceArrayOutput 

type EdgeCacheServiceArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceArrayOutput) ElementType 

func (EdgeCacheServiceArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceArrayOutput) Index 

func (o EdgeCacheServiceArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceOutput

func (EdgeCacheServiceArrayOutput) ToEdgeCacheServiceArrayOutput 

func (o EdgeCacheServiceArrayOutput) ToEdgeCacheServiceArrayOutput() EdgeCacheServiceArrayOutput

func (EdgeCacheServiceArrayOutput) ToEdgeCacheServiceArrayOutputWithContext 

func (o EdgeCacheServiceArrayOutput) ToEdgeCacheServiceArrayOutputWithContext(ctx context.Context) EdgeCacheServiceArrayOutput

type EdgeCacheServiceInput 

type EdgeCacheServiceInput interface {
	pulumi.Input

	ToEdgeCacheServiceOutput() EdgeCacheServiceOutput
	ToEdgeCacheServiceOutputWithContext(ctx context.Context) EdgeCacheServiceOutput
}

type EdgeCacheServiceLogConfig 

type EdgeCacheServiceLogConfig struct {
	// Specifies whether to enable logging for traffic served by this service.
	Enable *bool `pulumi:"enable"`
	// Configures the sampling rate of requests, where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0, and the value of the field must be in [0, 1].
	// This field can only be specified if logging is enabled for this service.
	SampleRate *float64 `pulumi:"sampleRate"`
}

type EdgeCacheServiceLogConfigArgs 

type EdgeCacheServiceLogConfigArgs struct {
	// Specifies whether to enable logging for traffic served by this service.
	Enable pulumi.BoolPtrInput `pulumi:"enable"`
	// Configures the sampling rate of requests, where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0, and the value of the field must be in [0, 1].
	// This field can only be specified if logging is enabled for this service.
	SampleRate pulumi.Float64PtrInput `pulumi:"sampleRate"`
}

func (EdgeCacheServiceLogConfigArgs) ElementType 

func (EdgeCacheServiceLogConfigArgs) ElementType() reflect.Type

func (EdgeCacheServiceLogConfigArgs) ToEdgeCacheServiceLogConfigOutput 

func (i EdgeCacheServiceLogConfigArgs) ToEdgeCacheServiceLogConfigOutput() EdgeCacheServiceLogConfigOutput

func (EdgeCacheServiceLogConfigArgs) ToEdgeCacheServiceLogConfigOutputWithContext 

func (i EdgeCacheServiceLogConfigArgs) ToEdgeCacheServiceLogConfigOutputWithContext(ctx context.Context) EdgeCacheServiceLogConfigOutput

func (EdgeCacheServiceLogConfigArgs) ToEdgeCacheServiceLogConfigPtrOutput 

func (i EdgeCacheServiceLogConfigArgs) ToEdgeCacheServiceLogConfigPtrOutput() EdgeCacheServiceLogConfigPtrOutput

func (EdgeCacheServiceLogConfigArgs) ToEdgeCacheServiceLogConfigPtrOutputWithContext 

func (i EdgeCacheServiceLogConfigArgs) ToEdgeCacheServiceLogConfigPtrOutputWithContext(ctx context.Context) EdgeCacheServiceLogConfigPtrOutput

type EdgeCacheServiceLogConfigInput 

type EdgeCacheServiceLogConfigInput interface {
	pulumi.Input

	ToEdgeCacheServiceLogConfigOutput() EdgeCacheServiceLogConfigOutput
	ToEdgeCacheServiceLogConfigOutputWithContext(context.Context) EdgeCacheServiceLogConfigOutput
}

EdgeCacheServiceLogConfigInput is an input type that accepts EdgeCacheServiceLogConfigArgs and EdgeCacheServiceLogConfigOutput values. You can construct a concrete instance of `EdgeCacheServiceLogConfigInput` via: 

EdgeCacheServiceLogConfigArgs{...}

type EdgeCacheServiceLogConfigOutput 

type EdgeCacheServiceLogConfigOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceLogConfigOutput) ElementType 

func (EdgeCacheServiceLogConfigOutput) ElementType() reflect.Type

func (EdgeCacheServiceLogConfigOutput) Enable 

func (o EdgeCacheServiceLogConfigOutput) Enable() pulumi.BoolPtrOutput

Specifies whether to enable logging for traffic served by this service.

func (EdgeCacheServiceLogConfigOutput) SampleRate 

func (o EdgeCacheServiceLogConfigOutput) SampleRate() pulumi.Float64PtrOutput

Configures the sampling rate of requests, where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0, and the value of the field must be in [0, 1]. This field can only be specified if logging is enabled for this service.

func (EdgeCacheServiceLogConfigOutput) ToEdgeCacheServiceLogConfigOutput 

func (o EdgeCacheServiceLogConfigOutput) ToEdgeCacheServiceLogConfigOutput() EdgeCacheServiceLogConfigOutput

func (EdgeCacheServiceLogConfigOutput) ToEdgeCacheServiceLogConfigOutputWithContext 

func (o EdgeCacheServiceLogConfigOutput) ToEdgeCacheServiceLogConfigOutputWithContext(ctx context.Context) EdgeCacheServiceLogConfigOutput

func (EdgeCacheServiceLogConfigOutput) ToEdgeCacheServiceLogConfigPtrOutput 

func (o EdgeCacheServiceLogConfigOutput) ToEdgeCacheServiceLogConfigPtrOutput() EdgeCacheServiceLogConfigPtrOutput

func (EdgeCacheServiceLogConfigOutput) ToEdgeCacheServiceLogConfigPtrOutputWithContext 

func (o EdgeCacheServiceLogConfigOutput) ToEdgeCacheServiceLogConfigPtrOutputWithContext(ctx context.Context) EdgeCacheServiceLogConfigPtrOutput

type EdgeCacheServiceLogConfigPtrInput 

type EdgeCacheServiceLogConfigPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceLogConfigPtrOutput() EdgeCacheServiceLogConfigPtrOutput
	ToEdgeCacheServiceLogConfigPtrOutputWithContext(context.Context) EdgeCacheServiceLogConfigPtrOutput
}

EdgeCacheServiceLogConfigPtrInput is an input type that accepts EdgeCacheServiceLogConfigArgs, EdgeCacheServiceLogConfigPtr and EdgeCacheServiceLogConfigPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceLogConfigPtrInput` via: 

        EdgeCacheServiceLogConfigArgs{...}

or:

        nil

func EdgeCacheServiceLogConfigPtr 

func EdgeCacheServiceLogConfigPtr(v *EdgeCacheServiceLogConfigArgs) EdgeCacheServiceLogConfigPtrInput

type EdgeCacheServiceLogConfigPtrOutput 

type EdgeCacheServiceLogConfigPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceLogConfigPtrOutput) Elem 

func (o EdgeCacheServiceLogConfigPtrOutput) Elem() EdgeCacheServiceLogConfigOutput

func (EdgeCacheServiceLogConfigPtrOutput) ElementType 

func (EdgeCacheServiceLogConfigPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceLogConfigPtrOutput) Enable 

func (o EdgeCacheServiceLogConfigPtrOutput) Enable() pulumi.BoolPtrOutput

Specifies whether to enable logging for traffic served by this service.

func (EdgeCacheServiceLogConfigPtrOutput) SampleRate 

func (o EdgeCacheServiceLogConfigPtrOutput) SampleRate() pulumi.Float64PtrOutput

Configures the sampling rate of requests, where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported. The default value is 1.0, and the value of the field must be in [0, 1]. This field can only be specified if logging is enabled for this service.

func (EdgeCacheServiceLogConfigPtrOutput) ToEdgeCacheServiceLogConfigPtrOutput 

func (o EdgeCacheServiceLogConfigPtrOutput) ToEdgeCacheServiceLogConfigPtrOutput() EdgeCacheServiceLogConfigPtrOutput

func (EdgeCacheServiceLogConfigPtrOutput) ToEdgeCacheServiceLogConfigPtrOutputWithContext 

func (o EdgeCacheServiceLogConfigPtrOutput) ToEdgeCacheServiceLogConfigPtrOutputWithContext(ctx context.Context) EdgeCacheServiceLogConfigPtrOutput

type EdgeCacheServiceMap 

type EdgeCacheServiceMap map[string]EdgeCacheServiceInput

func (EdgeCacheServiceMap) ElementType 

func (EdgeCacheServiceMap) ElementType() reflect.Type

func (EdgeCacheServiceMap) ToEdgeCacheServiceMapOutput 

func (i EdgeCacheServiceMap) ToEdgeCacheServiceMapOutput() EdgeCacheServiceMapOutput

func (EdgeCacheServiceMap) ToEdgeCacheServiceMapOutputWithContext 

func (i EdgeCacheServiceMap) ToEdgeCacheServiceMapOutputWithContext(ctx context.Context) EdgeCacheServiceMapOutput

type EdgeCacheServiceMapInput 

type EdgeCacheServiceMapInput interface {
	pulumi.Input

	ToEdgeCacheServiceMapOutput() EdgeCacheServiceMapOutput
	ToEdgeCacheServiceMapOutputWithContext(context.Context) EdgeCacheServiceMapOutput
}

EdgeCacheServiceMapInput is an input type that accepts EdgeCacheServiceMap and EdgeCacheServiceMapOutput values. You can construct a concrete instance of `EdgeCacheServiceMapInput` via: 

EdgeCacheServiceMap{ "key": EdgeCacheServiceArgs{...} }

type EdgeCacheServiceMapOutput 

type EdgeCacheServiceMapOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceMapOutput) ElementType 

func (EdgeCacheServiceMapOutput) ElementType() reflect.Type

func (EdgeCacheServiceMapOutput) MapIndex 

func (o EdgeCacheServiceMapOutput) MapIndex(k pulumi.StringInput) EdgeCacheServiceOutput

func (EdgeCacheServiceMapOutput) ToEdgeCacheServiceMapOutput 

func (o EdgeCacheServiceMapOutput) ToEdgeCacheServiceMapOutput() EdgeCacheServiceMapOutput

func (EdgeCacheServiceMapOutput) ToEdgeCacheServiceMapOutputWithContext 

func (o EdgeCacheServiceMapOutput) ToEdgeCacheServiceMapOutputWithContext(ctx context.Context) EdgeCacheServiceMapOutput

type EdgeCacheServiceOutput 

type EdgeCacheServiceOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceOutput) Description added in v6.23.0 

func (o EdgeCacheServiceOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheServiceOutput) DisableHttp2 added in v6.23.0 

func (o EdgeCacheServiceOutput) DisableHttp2() pulumi.BoolPtrOutput

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.

func (EdgeCacheServiceOutput) DisableQuic added in v6.23.0 

func (o EdgeCacheServiceOutput) DisableQuic() pulumi.BoolOutput

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

func (EdgeCacheServiceOutput) EdgeSecurityPolicy added in v6.23.0 

func (o EdgeCacheServiceOutput) EdgeSecurityPolicy() pulumi.StringPtrOutput

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

func (EdgeCacheServiceOutput) EdgeSslCertificates added in v6.23.0 

func (o EdgeCacheServiceOutput) EdgeSslCertificates() pulumi.StringArrayOutput

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.

func (EdgeCacheServiceOutput) ElementType 

func (EdgeCacheServiceOutput) ElementType() reflect.Type

func (EdgeCacheServiceOutput) Ipv4Addresses added in v6.23.0 

func (o EdgeCacheServiceOutput) Ipv4Addresses() pulumi.StringArrayOutput

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

func (EdgeCacheServiceOutput) Ipv6Addresses added in v6.23.0 

func (o EdgeCacheServiceOutput) Ipv6Addresses() pulumi.StringArrayOutput

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

func (EdgeCacheServiceOutput) Labels added in v6.23.0 

func (o EdgeCacheServiceOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the EdgeCache resource.

func (EdgeCacheServiceOutput) LogConfig added in v6.23.0 

func (o EdgeCacheServiceOutput) LogConfig() EdgeCacheServiceLogConfigPtrOutput

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.

func (EdgeCacheServiceOutput) Name added in v6.23.0 

func (o EdgeCacheServiceOutput) Name() pulumi.StringOutput

The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.

func (EdgeCacheServiceOutput) Project added in v6.23.0 

func (o EdgeCacheServiceOutput) Project() pulumi.StringOutput

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

func (EdgeCacheServiceOutput) RequireTls added in v6.23.0 

func (o EdgeCacheServiceOutput) RequireTls() pulumi.BoolOutput

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.

func (EdgeCacheServiceOutput) Routing added in v6.23.0 

func (o EdgeCacheServiceOutput) Routing() EdgeCacheServiceRoutingOutput

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

func (EdgeCacheServiceOutput) SslPolicy added in v6.23.0 

func (o EdgeCacheServiceOutput) SslPolicy() pulumi.StringPtrOutput

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.

func (EdgeCacheServiceOutput) ToEdgeCacheServiceOutput 

func (o EdgeCacheServiceOutput) ToEdgeCacheServiceOutput() EdgeCacheServiceOutput

func (EdgeCacheServiceOutput) ToEdgeCacheServiceOutputWithContext 

func (o EdgeCacheServiceOutput) ToEdgeCacheServiceOutputWithContext(ctx context.Context) EdgeCacheServiceOutput

type EdgeCacheServiceRouting 

type EdgeCacheServiceRouting struct {
	// The list of hostRules to match against. These rules define which hostnames the EdgeCacheService will match against, and which route configurations apply.
	// Structure is documented below.
	HostRules []EdgeCacheServiceRoutingHostRule `pulumi:"hostRules"`
	// The name of the pathMatcher associated with this hostRule.
	PathMatchers []EdgeCacheServiceRoutingPathMatcher `pulumi:"pathMatchers"`
}

type EdgeCacheServiceRoutingArgs 

type EdgeCacheServiceRoutingArgs struct {
	// The list of hostRules to match against. These rules define which hostnames the EdgeCacheService will match against, and which route configurations apply.
	// Structure is documented below.
	HostRules EdgeCacheServiceRoutingHostRuleArrayInput `pulumi:"hostRules"`
	// The name of the pathMatcher associated with this hostRule.
	PathMatchers EdgeCacheServiceRoutingPathMatcherArrayInput `pulumi:"pathMatchers"`
}

func (EdgeCacheServiceRoutingArgs) ElementType 

func (EdgeCacheServiceRoutingArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingArgs) ToEdgeCacheServiceRoutingOutput 

func (i EdgeCacheServiceRoutingArgs) ToEdgeCacheServiceRoutingOutput() EdgeCacheServiceRoutingOutput

func (EdgeCacheServiceRoutingArgs) ToEdgeCacheServiceRoutingOutputWithContext 

func (i EdgeCacheServiceRoutingArgs) ToEdgeCacheServiceRoutingOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingOutput

func (EdgeCacheServiceRoutingArgs) ToEdgeCacheServiceRoutingPtrOutput 

func (i EdgeCacheServiceRoutingArgs) ToEdgeCacheServiceRoutingPtrOutput() EdgeCacheServiceRoutingPtrOutput

func (EdgeCacheServiceRoutingArgs) ToEdgeCacheServiceRoutingPtrOutputWithContext 

func (i EdgeCacheServiceRoutingArgs) ToEdgeCacheServiceRoutingPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPtrOutput

type EdgeCacheServiceRoutingHostRule 

type EdgeCacheServiceRoutingHostRule struct {
	// A human-readable description of the resource.
	Description *string `pulumi:"description"`
	// The list of host patterns to match.
	// Host patterns must be valid hostnames. Ports are not allowed. Wildcard hosts are supported in the suffix or prefix form. * matches any string of ([a-z0-9-.]*). It does not match the empty string.
	// When multiple hosts are specified, hosts are matched in the following priority:
	// 1. Exact domain names: “www.foo.com“.
	// 2. Suffix domain wildcards: “*.foo.com“ or “*-bar.foo.com“.
	// 3. Prefix domain wildcards: “foo.*“ or “foo-*“.
	// 4. Special wildcard “*“ matching any domain.
	//    Notes:
	//    The wildcard will not match the empty string. e.g. “*-bar.foo.com“ will match “baz-bar.foo.com“ but not “-bar.foo.com“. The longest wildcards match first. Only a single host in the entire service can match on “*“. A domain must be unique across all configured hosts within a service.
	//    Hosts are matched against the HTTP Host header, or for HTTP/2 and HTTP/3, the ":authority" header, from the incoming request.
	//    You may specify up to 10 hosts.
	Hosts []string `pulumi:"hosts"`
	// The name of the pathMatcher associated with this hostRule.
	PathMatcher string `pulumi:"pathMatcher"`
}

type EdgeCacheServiceRoutingHostRuleArgs 

type EdgeCacheServiceRoutingHostRuleArgs struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// The list of host patterns to match.
	// Host patterns must be valid hostnames. Ports are not allowed. Wildcard hosts are supported in the suffix or prefix form. * matches any string of ([a-z0-9-.]*). It does not match the empty string.
	// When multiple hosts are specified, hosts are matched in the following priority:
	// 1. Exact domain names: “www.foo.com“.
	// 2. Suffix domain wildcards: “*.foo.com“ or “*-bar.foo.com“.
	// 3. Prefix domain wildcards: “foo.*“ or “foo-*“.
	// 4. Special wildcard “*“ matching any domain.
	//    Notes:
	//    The wildcard will not match the empty string. e.g. “*-bar.foo.com“ will match “baz-bar.foo.com“ but not “-bar.foo.com“. The longest wildcards match first. Only a single host in the entire service can match on “*“. A domain must be unique across all configured hosts within a service.
	//    Hosts are matched against the HTTP Host header, or for HTTP/2 and HTTP/3, the ":authority" header, from the incoming request.
	//    You may specify up to 10 hosts.
	Hosts pulumi.StringArrayInput `pulumi:"hosts"`
	// The name of the pathMatcher associated with this hostRule.
	PathMatcher pulumi.StringInput `pulumi:"pathMatcher"`
}

func (EdgeCacheServiceRoutingHostRuleArgs) ElementType 

func (EdgeCacheServiceRoutingHostRuleArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingHostRuleArgs) ToEdgeCacheServiceRoutingHostRuleOutput 

func (i EdgeCacheServiceRoutingHostRuleArgs) ToEdgeCacheServiceRoutingHostRuleOutput() EdgeCacheServiceRoutingHostRuleOutput

func (EdgeCacheServiceRoutingHostRuleArgs) ToEdgeCacheServiceRoutingHostRuleOutputWithContext 

func (i EdgeCacheServiceRoutingHostRuleArgs) ToEdgeCacheServiceRoutingHostRuleOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingHostRuleOutput

type EdgeCacheServiceRoutingHostRuleArray 

type EdgeCacheServiceRoutingHostRuleArray []EdgeCacheServiceRoutingHostRuleInput

func (EdgeCacheServiceRoutingHostRuleArray) ElementType 

func (EdgeCacheServiceRoutingHostRuleArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingHostRuleArray) ToEdgeCacheServiceRoutingHostRuleArrayOutput 

func (i EdgeCacheServiceRoutingHostRuleArray) ToEdgeCacheServiceRoutingHostRuleArrayOutput() EdgeCacheServiceRoutingHostRuleArrayOutput

func (EdgeCacheServiceRoutingHostRuleArray) ToEdgeCacheServiceRoutingHostRuleArrayOutputWithContext 

func (i EdgeCacheServiceRoutingHostRuleArray) ToEdgeCacheServiceRoutingHostRuleArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingHostRuleArrayOutput

type EdgeCacheServiceRoutingHostRuleArrayInput 

type EdgeCacheServiceRoutingHostRuleArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingHostRuleArrayOutput() EdgeCacheServiceRoutingHostRuleArrayOutput
	ToEdgeCacheServiceRoutingHostRuleArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingHostRuleArrayOutput
}

EdgeCacheServiceRoutingHostRuleArrayInput is an input type that accepts EdgeCacheServiceRoutingHostRuleArray and EdgeCacheServiceRoutingHostRuleArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingHostRuleArrayInput` via: 

EdgeCacheServiceRoutingHostRuleArray{ EdgeCacheServiceRoutingHostRuleArgs{...} }

type EdgeCacheServiceRoutingHostRuleArrayOutput 

type EdgeCacheServiceRoutingHostRuleArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingHostRuleArrayOutput) ElementType 

func (EdgeCacheServiceRoutingHostRuleArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingHostRuleArrayOutput) Index 

func (o EdgeCacheServiceRoutingHostRuleArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingHostRuleOutput

func (EdgeCacheServiceRoutingHostRuleArrayOutput) ToEdgeCacheServiceRoutingHostRuleArrayOutput 

func (o EdgeCacheServiceRoutingHostRuleArrayOutput) ToEdgeCacheServiceRoutingHostRuleArrayOutput() EdgeCacheServiceRoutingHostRuleArrayOutput

func (EdgeCacheServiceRoutingHostRuleArrayOutput) ToEdgeCacheServiceRoutingHostRuleArrayOutputWithContext 

func (o EdgeCacheServiceRoutingHostRuleArrayOutput) ToEdgeCacheServiceRoutingHostRuleArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingHostRuleArrayOutput

type EdgeCacheServiceRoutingHostRuleInput 

type EdgeCacheServiceRoutingHostRuleInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingHostRuleOutput() EdgeCacheServiceRoutingHostRuleOutput
	ToEdgeCacheServiceRoutingHostRuleOutputWithContext(context.Context) EdgeCacheServiceRoutingHostRuleOutput
}

EdgeCacheServiceRoutingHostRuleInput is an input type that accepts EdgeCacheServiceRoutingHostRuleArgs and EdgeCacheServiceRoutingHostRuleOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingHostRuleInput` via: 

EdgeCacheServiceRoutingHostRuleArgs{...}

type EdgeCacheServiceRoutingHostRuleOutput 

type EdgeCacheServiceRoutingHostRuleOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingHostRuleOutput) Description 

func (o EdgeCacheServiceRoutingHostRuleOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheServiceRoutingHostRuleOutput) ElementType 

func (EdgeCacheServiceRoutingHostRuleOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingHostRuleOutput) Hosts 

func (o EdgeCacheServiceRoutingHostRuleOutput) Hosts() pulumi.StringArrayOutput

The list of host patterns to match. Host patterns must be valid hostnames. Ports are not allowed. Wildcard hosts are supported in the suffix or prefix form. * matches any string of ([a-z0-9-.]*). It does not match the empty string. When multiple hosts are specified, hosts are matched in the following priority:

  1. Exact domain names: “www.foo.com“.
  2. Suffix domain wildcards: “*.foo.com“ or “*-bar.foo.com“.
  3. Prefix domain wildcards: “foo.*“ or “foo-*“.
  4. Special wildcard “*“ matching any domain. Notes: The wildcard will not match the empty string. e.g. “*-bar.foo.com“ will match “baz-bar.foo.com“ but not “-bar.foo.com“. The longest wildcards match first. Only a single host in the entire service can match on “*“. A domain must be unique across all configured hosts within a service. Hosts are matched against the HTTP Host header, or for HTTP/2 and HTTP/3, the ":authority" header, from the incoming request. You may specify up to 10 hosts.

func (EdgeCacheServiceRoutingHostRuleOutput) PathMatcher 

func (o EdgeCacheServiceRoutingHostRuleOutput) PathMatcher() pulumi.StringOutput

The name of the pathMatcher associated with this hostRule.

func (EdgeCacheServiceRoutingHostRuleOutput) ToEdgeCacheServiceRoutingHostRuleOutput 

func (o EdgeCacheServiceRoutingHostRuleOutput) ToEdgeCacheServiceRoutingHostRuleOutput() EdgeCacheServiceRoutingHostRuleOutput

func (EdgeCacheServiceRoutingHostRuleOutput) ToEdgeCacheServiceRoutingHostRuleOutputWithContext 

func (o EdgeCacheServiceRoutingHostRuleOutput) ToEdgeCacheServiceRoutingHostRuleOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingHostRuleOutput

type EdgeCacheServiceRoutingInput 

type EdgeCacheServiceRoutingInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingOutput() EdgeCacheServiceRoutingOutput
	ToEdgeCacheServiceRoutingOutputWithContext(context.Context) EdgeCacheServiceRoutingOutput
}

EdgeCacheServiceRoutingInput is an input type that accepts EdgeCacheServiceRoutingArgs and EdgeCacheServiceRoutingOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingInput` via: 

EdgeCacheServiceRoutingArgs{...}

type EdgeCacheServiceRoutingOutput 

type EdgeCacheServiceRoutingOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingOutput) ElementType 

func (EdgeCacheServiceRoutingOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingOutput) HostRules 

func (o EdgeCacheServiceRoutingOutput) HostRules() EdgeCacheServiceRoutingHostRuleArrayOutput

The list of hostRules to match against. These rules define which hostnames the EdgeCacheService will match against, and which route configurations apply. Structure is documented below.

func (EdgeCacheServiceRoutingOutput) PathMatchers 

func (o EdgeCacheServiceRoutingOutput) PathMatchers() EdgeCacheServiceRoutingPathMatcherArrayOutput

The name of the pathMatcher associated with this hostRule.

func (EdgeCacheServiceRoutingOutput) ToEdgeCacheServiceRoutingOutput 

func (o EdgeCacheServiceRoutingOutput) ToEdgeCacheServiceRoutingOutput() EdgeCacheServiceRoutingOutput

func (EdgeCacheServiceRoutingOutput) ToEdgeCacheServiceRoutingOutputWithContext 

func (o EdgeCacheServiceRoutingOutput) ToEdgeCacheServiceRoutingOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingOutput

func (EdgeCacheServiceRoutingOutput) ToEdgeCacheServiceRoutingPtrOutput 

func (o EdgeCacheServiceRoutingOutput) ToEdgeCacheServiceRoutingPtrOutput() EdgeCacheServiceRoutingPtrOutput

func (EdgeCacheServiceRoutingOutput) ToEdgeCacheServiceRoutingPtrOutputWithContext 

func (o EdgeCacheServiceRoutingOutput) ToEdgeCacheServiceRoutingPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPtrOutput

type EdgeCacheServiceRoutingPathMatcher 

type EdgeCacheServiceRoutingPathMatcher struct {
	// A human-readable description of the resource.
	Description *string `pulumi:"description"`
	// The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
	Name string `pulumi:"name"`
	// The routeRules to match against. routeRules support advanced routing behaviour, and can match on paths, headers and query parameters, as well as status codes and HTTP methods.
	// Structure is documented below.
	RouteRules []EdgeCacheServiceRoutingPathMatcherRouteRule `pulumi:"routeRules"`
}

type EdgeCacheServiceRoutingPathMatcherArgs 

type EdgeCacheServiceRoutingPathMatcherArgs struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
	Name pulumi.StringInput `pulumi:"name"`
	// The routeRules to match against. routeRules support advanced routing behaviour, and can match on paths, headers and query parameters, as well as status codes and HTTP methods.
	// Structure is documented below.
	RouteRules EdgeCacheServiceRoutingPathMatcherRouteRuleArrayInput `pulumi:"routeRules"`
}

func (EdgeCacheServiceRoutingPathMatcherArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherArgs) ToEdgeCacheServiceRoutingPathMatcherOutput 

func (i EdgeCacheServiceRoutingPathMatcherArgs) ToEdgeCacheServiceRoutingPathMatcherOutput() EdgeCacheServiceRoutingPathMatcherOutput

func (EdgeCacheServiceRoutingPathMatcherArgs) ToEdgeCacheServiceRoutingPathMatcherOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherArgs) ToEdgeCacheServiceRoutingPathMatcherOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherOutput

type EdgeCacheServiceRoutingPathMatcherArray 

type EdgeCacheServiceRoutingPathMatcherArray []EdgeCacheServiceRoutingPathMatcherInput

func (EdgeCacheServiceRoutingPathMatcherArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherArray) ToEdgeCacheServiceRoutingPathMatcherArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherArray) ToEdgeCacheServiceRoutingPathMatcherArrayOutput() EdgeCacheServiceRoutingPathMatcherArrayOutput

func (EdgeCacheServiceRoutingPathMatcherArray) ToEdgeCacheServiceRoutingPathMatcherArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherArray) ToEdgeCacheServiceRoutingPathMatcherArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherArrayOutput

type EdgeCacheServiceRoutingPathMatcherArrayInput 

type EdgeCacheServiceRoutingPathMatcherArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherArrayOutput() EdgeCacheServiceRoutingPathMatcherArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherArrayOutput
}

EdgeCacheServiceRoutingPathMatcherArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherArray and EdgeCacheServiceRoutingPathMatcherArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherArray{ EdgeCacheServiceRoutingPathMatcherArgs{...} }

type EdgeCacheServiceRoutingPathMatcherArrayOutput 

type EdgeCacheServiceRoutingPathMatcherArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherOutput

func (EdgeCacheServiceRoutingPathMatcherArrayOutput) ToEdgeCacheServiceRoutingPathMatcherArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherArrayOutput) ToEdgeCacheServiceRoutingPathMatcherArrayOutput() EdgeCacheServiceRoutingPathMatcherArrayOutput

func (EdgeCacheServiceRoutingPathMatcherArrayOutput) ToEdgeCacheServiceRoutingPathMatcherArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherArrayOutput) ToEdgeCacheServiceRoutingPathMatcherArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherArrayOutput

type EdgeCacheServiceRoutingPathMatcherInput 

type EdgeCacheServiceRoutingPathMatcherInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherOutput() EdgeCacheServiceRoutingPathMatcherOutput
	ToEdgeCacheServiceRoutingPathMatcherOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherOutput
}

EdgeCacheServiceRoutingPathMatcherInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherArgs and EdgeCacheServiceRoutingPathMatcherOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherInput` via: 

EdgeCacheServiceRoutingPathMatcherArgs{...}

type EdgeCacheServiceRoutingPathMatcherOutput 

type EdgeCacheServiceRoutingPathMatcherOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherOutput) Description 

func (o EdgeCacheServiceRoutingPathMatcherOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheServiceRoutingPathMatcherOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherOutput) Name 

func (o EdgeCacheServiceRoutingPathMatcherOutput) Name() pulumi.StringOutput

The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.

func (EdgeCacheServiceRoutingPathMatcherOutput) RouteRules 

func (o EdgeCacheServiceRoutingPathMatcherOutput) RouteRules() EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput

The routeRules to match against. routeRules support advanced routing behaviour, and can match on paths, headers and query parameters, as well as status codes and HTTP methods. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherOutput) ToEdgeCacheServiceRoutingPathMatcherOutput 

func (o EdgeCacheServiceRoutingPathMatcherOutput) ToEdgeCacheServiceRoutingPathMatcherOutput() EdgeCacheServiceRoutingPathMatcherOutput

func (EdgeCacheServiceRoutingPathMatcherOutput) ToEdgeCacheServiceRoutingPathMatcherOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherOutput) ToEdgeCacheServiceRoutingPathMatcherOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherOutput

type EdgeCacheServiceRoutingPathMatcherRouteRule 

type EdgeCacheServiceRoutingPathMatcherRouteRule struct {
	// A human-readable description of the resource.
	Description *string `pulumi:"description"`
	// The header actions, including adding & removing headers, for requests that match this route.
	// Structure is documented below.
	HeaderAction *EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderAction `pulumi:"headerAction"`
	// The list of criteria for matching attributes of a request to this routeRule. This list has OR semantics: the request matches this routeRule when any of the matchRules are satisfied. However predicates
	// within a given matchRule have AND semantics. All predicates within a matchRule must match for the request to match the rule.
	// Structure is documented below.
	MatchRules []EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRule `pulumi:"matchRules"`
	// The Origin resource that requests to this route should fetch from when a matching response is not in cache. Origins can be defined as short names ("my-origin") or fully-qualified resource URLs - e.g. "networkservices.googleapis.com/projects/my-project/global/edgecacheorigins/my-origin"
	// Only one of origin or urlRedirect can be set.
	Origin *string `pulumi:"origin"`
	// The priority of this route rule, where 1 is the highest priority.
	// You cannot configure two or more routeRules with the same priority. Priority for each rule must be set to a number between 1 and 999 inclusive.
	// Priority numbers can have gaps, which enable you to add or remove rules in the future without affecting the rest of the rules. For example, 1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers
	// to which you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the future without any impact on existing rules.
	Priority string `pulumi:"priority"`
	// In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin.
	// Structure is documented below.
	RouteAction *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteAction `pulumi:"routeAction"`
	// The URL redirect configuration for requests that match this route.
	// Structure is documented below.
	UrlRedirect *EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirect `pulumi:"urlRedirect"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleArgs struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// The header actions, including adding & removing headers, for requests that match this route.
	// Structure is documented below.
	HeaderAction EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrInput `pulumi:"headerAction"`
	// The list of criteria for matching attributes of a request to this routeRule. This list has OR semantics: the request matches this routeRule when any of the matchRules are satisfied. However predicates
	// within a given matchRule have AND semantics. All predicates within a matchRule must match for the request to match the rule.
	// Structure is documented below.
	MatchRules EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayInput `pulumi:"matchRules"`
	// The Origin resource that requests to this route should fetch from when a matching response is not in cache. Origins can be defined as short names ("my-origin") or fully-qualified resource URLs - e.g. "networkservices.googleapis.com/projects/my-project/global/edgecacheorigins/my-origin"
	// Only one of origin or urlRedirect can be set.
	Origin pulumi.StringPtrInput `pulumi:"origin"`
	// The priority of this route rule, where 1 is the highest priority.
	// You cannot configure two or more routeRules with the same priority. Priority for each rule must be set to a number between 1 and 999 inclusive.
	// Priority numbers can have gaps, which enable you to add or remove rules in the future without affecting the rest of the rules. For example, 1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers
	// to which you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the future without any impact on existing rules.
	Priority pulumi.StringInput `pulumi:"priority"`
	// In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin.
	// Structure is documented below.
	RouteAction EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrInput `pulumi:"routeAction"`
	// The URL redirect configuration for requests that match this route.
	// Structure is documented below.
	UrlRedirect EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrInput `pulumi:"urlRedirect"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleArray 

type EdgeCacheServiceRoutingPathMatcherRouteRuleArray []EdgeCacheServiceRoutingPathMatcherRouteRuleInput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleArrayInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleArray and EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleArray{ EdgeCacheServiceRoutingPathMatcherRouteRuleArgs{...} }

type EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherRouteRuleOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderAction 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderAction struct {
	// Describes a header to add.
	// Structure is documented below.
	RequestHeaderToAdds []EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAdd `pulumi:"requestHeaderToAdds"`
	// A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
	// Structure is documented below.
	RequestHeaderToRemoves []EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemove `pulumi:"requestHeaderToRemoves"`
	// Headers to add to the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	// Structure is documented below.
	ResponseHeaderToAdds []EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAdd `pulumi:"responseHeaderToAdds"`
	// A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
	// Structure is documented below.
	ResponseHeaderToRemoves []EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemove `pulumi:"responseHeaderToRemoves"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs struct {
	// Describes a header to add.
	// Structure is documented below.
	RequestHeaderToAdds EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayInput `pulumi:"requestHeaderToAdds"`
	// A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
	// Structure is documented below.
	RequestHeaderToRemoves EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayInput `pulumi:"requestHeaderToRemoves"`
	// Headers to add to the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	// Structure is documented below.
	ResponseHeaderToAdds EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayInput `pulumi:"responseHeaderToAdds"`
	// A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin.
	// Structure is documented below.
	ResponseHeaderToRemoves EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayInput `pulumi:"responseHeaderToRemoves"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) RequestHeaderToAdds 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) RequestHeaderToAdds() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput

Describes a header to add. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) RequestHeaderToRemoves 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) RequestHeaderToRemoves() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput

A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ResponseHeaderToAdds 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ResponseHeaderToAdds() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput

Headers to add to the response prior to sending it back to the client. Response headers are only sent to the client, and do not have an effect on the cache serving the response. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ResponseHeaderToRemoves 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ResponseHeaderToRemoves() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput

A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtr and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtr 

func EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) Elem 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) RequestHeaderToAdds 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) RequestHeaderToAdds() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput

Describes a header to add. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) RequestHeaderToRemoves 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) RequestHeaderToRemoves() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput

A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ResponseHeaderToAdds 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ResponseHeaderToAdds() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput

Headers to add to the response prior to sending it back to the client. Response headers are only sent to the client, and do not have an effect on the cache serving the response. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ResponseHeaderToRemoves 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ResponseHeaderToRemoves() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput

A list of header names for headers that need to be removed from the request prior to forwarding the request to the origin. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAdd 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAdd struct {
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName string `pulumi:"headerName"`
	// The value of the header to add.
	HeaderValue string `pulumi:"headerValue"`
	// Whether to replace all existing headers with the same name.
	Replace *bool `pulumi:"replace"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs struct {
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName pulumi.StringInput `pulumi:"headerName"`
	// The value of the header to add.
	HeaderValue pulumi.StringInput `pulumi:"headerValue"`
	// Whether to replace all existing headers with the same name.
	Replace pulumi.BoolPtrInput `pulumi:"replace"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray []EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddInput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArray{ EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs{...} }

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) HeaderName 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) HeaderName() pulumi.StringOutput

Headers to remove from the response prior to sending it back to the client. Response headers are only sent to the client, and do not have an effect on the cache serving the response.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) HeaderValue 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) HeaderValue() pulumi.StringOutput

The value of the header to add.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) Replace 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) Replace() pulumi.BoolPtrOutput

Whether to replace all existing headers with the same name.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToAddOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemove 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemove struct {
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName string `pulumi:"headerName"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs struct {
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName pulumi.StringInput `pulumi:"headerName"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray []EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveInput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArray{ EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs{...} }

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) HeaderName 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) HeaderName() pulumi.StringOutput

Headers to remove from the response prior to sending it back to the client. Response headers are only sent to the client, and do not have an effect on the cache serving the response.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAdd 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAdd struct {
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName string `pulumi:"headerName"`
	// The value of the header to add.
	HeaderValue string `pulumi:"headerValue"`
	// Whether to replace all existing headers with the same name.
	Replace *bool `pulumi:"replace"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs struct {
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName pulumi.StringInput `pulumi:"headerName"`
	// The value of the header to add.
	HeaderValue pulumi.StringInput `pulumi:"headerValue"`
	// Whether to replace all existing headers with the same name.
	Replace pulumi.BoolPtrInput `pulumi:"replace"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray []EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddInput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArray{ EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs{...} }

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) HeaderName 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) HeaderName() pulumi.StringOutput

Headers to remove from the response prior to sending it back to the client. Response headers are only sent to the client, and do not have an effect on the cache serving the response.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) HeaderValue 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) HeaderValue() pulumi.StringOutput

The value of the header to add.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) Replace 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) Replace() pulumi.BoolPtrOutput

Whether to replace all existing headers with the same name.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAddOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemove 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemove struct {
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName string `pulumi:"headerName"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs struct {
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName pulumi.StringInput `pulumi:"headerName"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray []EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveInput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArray{ EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs{...} }

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput) HeaderName 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput) HeaderName() pulumi.StringOutput

Headers to remove from the response prior to sending it back to the client. Response headers are only sent to the client, and do not have an effect on the cache serving the response.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToRemoveOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRule 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRule struct {
	// For satisfying the matchRule condition, the path of the request must exactly match the value specified in fullPathMatch after removing any query parameters and anchor that may be part of the original URL.
	FullPathMatch *string `pulumi:"fullPathMatch"`
	// Specifies a list of header match criteria, all of which must match corresponding headers in the request.
	// Structure is documented below.
	HeaderMatches []EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatch `pulumi:"headerMatches"`
	// Specifies that prefixMatch and fullPathMatch matches are case sensitive.
	IgnoreCase *bool `pulumi:"ignoreCase"`
	// For satisfying the matchRule condition, the path of the request
	// must match the wildcard pattern specified in pathTemplateMatch
	// after removing any query parameters and anchor that may be part
	// of the original URL.
	// pathTemplateMatch must be between 1 and 255 characters
	// (inclusive).  The pattern specified by pathTemplateMatch may
	// have at most 5 wildcard operators and at most 5 variable
	// captures in total.
	PathTemplateMatch *string `pulumi:"pathTemplateMatch"`
	// The value of the header must start with the contents of prefixMatch.
	PrefixMatch *string `pulumi:"prefixMatch"`
	// Specifies a list of query parameter match criteria, all of which must match corresponding query parameters in the request.
	// Structure is documented below.
	QueryParameterMatches []EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatch `pulumi:"queryParameterMatches"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs struct {
	// For satisfying the matchRule condition, the path of the request must exactly match the value specified in fullPathMatch after removing any query parameters and anchor that may be part of the original URL.
	FullPathMatch pulumi.StringPtrInput `pulumi:"fullPathMatch"`
	// Specifies a list of header match criteria, all of which must match corresponding headers in the request.
	// Structure is documented below.
	HeaderMatches EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayInput `pulumi:"headerMatches"`
	// Specifies that prefixMatch and fullPathMatch matches are case sensitive.
	IgnoreCase pulumi.BoolPtrInput `pulumi:"ignoreCase"`
	// For satisfying the matchRule condition, the path of the request
	// must match the wildcard pattern specified in pathTemplateMatch
	// after removing any query parameters and anchor that may be part
	// of the original URL.
	// pathTemplateMatch must be between 1 and 255 characters
	// (inclusive).  The pattern specified by pathTemplateMatch may
	// have at most 5 wildcard operators and at most 5 variable
	// captures in total.
	PathTemplateMatch pulumi.StringPtrInput `pulumi:"pathTemplateMatch"`
	// The value of the header must start with the contents of prefixMatch.
	PrefixMatch pulumi.StringPtrInput `pulumi:"prefixMatch"`
	// Specifies a list of query parameter match criteria, all of which must match corresponding query parameters in the request.
	// Structure is documented below.
	QueryParameterMatches EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayInput `pulumi:"queryParameterMatches"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray []EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleInput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray and EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArray{ EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{...} }

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatch 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatch struct {
	// The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.
	ExactMatch *string `pulumi:"exactMatch"`
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName string `pulumi:"headerName"`
	// If set to false (default), the headerMatch is considered a match if the match criteria above are met.
	// If set to true, the headerMatch is considered a match if the match criteria above are NOT met.
	InvertMatch *bool `pulumi:"invertMatch"`
	// The value of the header must start with the contents of prefixMatch.
	PrefixMatch *string `pulumi:"prefixMatch"`
	// Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.
	PresentMatch *bool `pulumi:"presentMatch"`
	// The value of the header must end with the contents of suffixMatch.
	SuffixMatch *string `pulumi:"suffixMatch"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs struct {
	// The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.
	ExactMatch pulumi.StringPtrInput `pulumi:"exactMatch"`
	// Headers to remove from the response prior to sending it back to the client.
	// Response headers are only sent to the client, and do not have an effect on the cache serving the response.
	HeaderName pulumi.StringInput `pulumi:"headerName"`
	// If set to false (default), the headerMatch is considered a match if the match criteria above are met.
	// If set to true, the headerMatch is considered a match if the match criteria above are NOT met.
	InvertMatch pulumi.BoolPtrInput `pulumi:"invertMatch"`
	// The value of the header must start with the contents of prefixMatch.
	PrefixMatch pulumi.StringPtrInput `pulumi:"prefixMatch"`
	// Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.
	PresentMatch pulumi.BoolPtrInput `pulumi:"presentMatch"`
	// The value of the header must end with the contents of suffixMatch.
	SuffixMatch pulumi.StringPtrInput `pulumi:"suffixMatch"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray []EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchInput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray and EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArray{ EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs{...} }

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) ExactMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) ExactMatch() pulumi.StringPtrOutput

The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) HeaderName 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) HeaderName() pulumi.StringOutput

Headers to remove from the response prior to sending it back to the client. Response headers are only sent to the client, and do not have an effect on the cache serving the response.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) InvertMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) InvertMatch() pulumi.BoolPtrOutput

If set to false (default), the headerMatch is considered a match if the match criteria above are met. If set to true, the headerMatch is considered a match if the match criteria above are NOT met.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) PrefixMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) PrefixMatch() pulumi.StringPtrOutput

The value of the header must start with the contents of prefixMatch.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) PresentMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) PresentMatch() pulumi.BoolPtrOutput

Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) SuffixMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) SuffixMatch() pulumi.StringPtrOutput

The value of the header must end with the contents of suffixMatch.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) FullPathMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) FullPathMatch() pulumi.StringPtrOutput

For satisfying the matchRule condition, the path of the request must exactly match the value specified in fullPathMatch after removing any query parameters and anchor that may be part of the original URL.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) HeaderMatches 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) HeaderMatches() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchArrayOutput

Specifies a list of header match criteria, all of which must match corresponding headers in the request. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) IgnoreCase 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) IgnoreCase() pulumi.BoolPtrOutput

Specifies that prefixMatch and fullPathMatch matches are case sensitive.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) PathTemplateMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) PathTemplateMatch() pulumi.StringPtrOutput

For satisfying the matchRule condition, the path of the request must match the wildcard pattern specified in pathTemplateMatch after removing any query parameters and anchor that may be part of the original URL. pathTemplateMatch must be between 1 and 255 characters (inclusive). The pattern specified by pathTemplateMatch may have at most 5 wildcard operators and at most 5 variable captures in total.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) PrefixMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) PrefixMatch() pulumi.StringPtrOutput

The value of the header must start with the contents of prefixMatch.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) QueryParameterMatches 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) QueryParameterMatches() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput

Specifies a list of query parameter match criteria, all of which must match corresponding query parameters in the request. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatch 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatch struct {
	// The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.
	ExactMatch *string `pulumi:"exactMatch"`
	// The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
	Name string `pulumi:"name"`
	// Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.
	PresentMatch *bool `pulumi:"presentMatch"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs struct {
	// The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.
	ExactMatch pulumi.StringPtrInput `pulumi:"exactMatch"`
	// The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
	Name pulumi.StringInput `pulumi:"name"`
	// Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.
	PresentMatch pulumi.BoolPtrInput `pulumi:"presentMatch"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray []EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchInput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray and EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArray{ EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs{...} }

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput) Index 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput) Index(i pulumi.IntInput) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArrayOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) ExactMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) ExactMatch() pulumi.StringPtrOutput

The queryParameterMatch matches if the value of the parameter exactly matches the contents of exactMatch.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) Name 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) Name() pulumi.StringOutput

The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) PresentMatch 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) PresentMatch() pulumi.BoolPtrOutput

Specifies that the queryParameterMatch matches if the request contains the query parameter, irrespective of whether the parameter has a value or not.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleQueryParameterMatchOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) Description 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) Description() pulumi.StringPtrOutput

A human-readable description of the resource.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) HeaderAction 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) HeaderAction() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionPtrOutput

The header actions, including adding & removing headers, for requests that match this route. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) MatchRules 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) MatchRules() EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleArrayOutput

The list of criteria for matching attributes of a request to this routeRule. This list has OR semantics: the request matches this routeRule when any of the matchRules are satisfied. However predicates within a given matchRule have AND semantics. All predicates within a matchRule must match for the request to match the rule. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) Origin 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) Origin() pulumi.StringPtrOutput

The Origin resource that requests to this route should fetch from when a matching response is not in cache. Origins can be defined as short names ("my-origin") or fully-qualified resource URLs - e.g. "networkservices.googleapis.com/projects/my-project/global/edgecacheorigins/my-origin" Only one of origin or urlRedirect can be set.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) Priority 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) Priority() pulumi.StringOutput

The priority of this route rule, where 1 is the highest priority. You cannot configure two or more routeRules with the same priority. Priority for each rule must be set to a number between 1 and 999 inclusive. Priority numbers can have gaps, which enable you to add or remove rules in the future without affecting the rest of the rules. For example, 1, 2, 3, 4, 5, 9, 12, 16 is a valid series of priority numbers to which you could add rules numbered from 6 to 8, 10 to 11, and 13 to 15 in the future without any impact on existing rules.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) RouteAction 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) RouteAction() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput

In response to a matching path, the routeAction performs advanced routing actions like URL rewrites, header transformations, etc. prior to forwarding the request to the selected origin. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) UrlRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleOutput) UrlRedirect() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput

The URL redirect configuration for requests that match this route. Structure is documented below.

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteAction 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteAction struct {
	// The policy to use for defining caching and signed request behaviour for requests that match this route.
	// Structure is documented below.
	CdnPolicy *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicy `pulumi:"cdnPolicy"`
	// CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
	// Structure is documented below.
	CorsPolicy *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicy `pulumi:"corsPolicy"`
	// The URL rewrite configuration for requests that match this route.
	// Structure is documented below.
	UrlRewrite *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewrite `pulumi:"urlRewrite"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs struct {
	// The policy to use for defining caching and signed request behaviour for requests that match this route.
	// Structure is documented below.
	CdnPolicy EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrInput `pulumi:"cdnPolicy"`
	// CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set.
	// Structure is documented below.
	CorsPolicy EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrInput `pulumi:"corsPolicy"`
	// The URL rewrite configuration for requests that match this route.
	// Structure is documented below.
	UrlRewrite EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrInput `pulumi:"urlRewrite"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicy 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicy struct {
	// Defines the request parameters that contribute to the cache key.
	// Structure is documented below.
	CacheKeyPolicy *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicy `pulumi:"cacheKeyPolicy"`
	// Cache modes allow users to control the behaviour of the cache, what content it should cache automatically, whether to respect origin headers, or whether to unconditionally cache all responses.
	// For all cache modes, Cache-Control headers will be passed to the client. Use clientTtl to override what is sent to the client.
	// Possible values are `CACHE_ALL_STATIC`, `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `BYPASS_CACHE`.
	CacheMode *string `pulumi:"cacheMode"`
	// Specifies a separate client (e.g. browser client) TTL, separate from the TTL used by the edge caches. Leaving this empty will use the same cache TTL for both the CDN and the client-facing response.
	// - The TTL must be > 0 and <= 86400s (1 day)
	// - The clientTtl cannot be larger than the defaultTtl (if set)
	// - Fractions of a second are not allowed.
	//   Omit this field to use the defaultTtl, or the max-age set by the origin, as the client-facing TTL.
	//   When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
	//   A duration in seconds terminated by 's'. Example: "3s".
	ClientTtl *string `pulumi:"clientTtl"`
	// Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age).
	// Defaults to 3600s (1 hour).
	// - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
	// - Setting a TTL of "0" means "always revalidate" (equivalent to must-revalidate)
	// - The value of defaultTTL cannot be set to a value greater than that of maxTTL.
	// - Fractions of a second are not allowed.
	// - When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses.
	//   Note that infrequently accessed objects may be evicted from the cache before the defined TTL. Objects that expire will be revalidated with the origin.
	//   When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
	//   A duration in seconds terminated by 's'. Example: "3s".
	DefaultTtl *string `pulumi:"defaultTtl"`
	// Specifies the maximum allowed TTL for cached content served by this origin.
	// Defaults to 86400s (1 day).
	// Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTtl seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive.
	// - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
	// - Setting a TTL of "0" means "always revalidate"
	// - The value of maxTtl must be equal to or greater than defaultTtl.
	// - Fractions of a second are not allowed.
	//   When the cache mode is set to "USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", or "BYPASS_CACHE", you must omit this field.
	//   A duration in seconds terminated by 's'. Example: "3s".
	MaxTtl *string `pulumi:"maxTtl"`
	// Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency.
	// By default, the CDNPolicy will apply the following default TTLs to these status codes:
	// - HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m
	// - HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s
	// - HTTP 405 (Method Not Found), 414 (URI Too Long), 501 (Not Implemented): 60s
	//   These defaults can be overridden in negativeCachingPolicy
	NegativeCaching *bool `pulumi:"negativeCaching"`
	// Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
	// - Omitting the policy and leaving negativeCaching enabled will use the default TTLs for each status code, defined in negativeCaching.
	// - TTLs must be >= 0 (where 0 is "always revalidate") and <= 86400s (1 day)
	//   Note that when specifying an explicit negativeCachingPolicy, you should take care to specify a cache TTL for all response codes that you wish to cache. The CDNPolicy will not apply any default negative caching when a policy exists.
	NegativeCachingPolicy map[string]string `pulumi:"negativeCachingPolicy"`
	// The EdgeCacheKeyset containing the set of public keys used to validate signed requests at the edge.
	SignedRequestKeyset *string `pulumi:"signedRequestKeyset"`
	// Whether to enforce signed requests. The default value is DISABLED, which means all content is public, and does not authorize access.
	// You must also set a signedRequestKeyset to enable signed requests.
	// When set to REQUIRE_SIGNATURES, all matching requests will have their signature validated. Requests that were not signed with the corresponding private key, or that are otherwise invalid (expired, do not match the signature, IP address, or header) will be rejected with a HTTP 403 and (if enabled) logged.
	// Possible values are `DISABLED` and `REQUIRE_SIGNATURES`.
	SignedRequestMode *string `pulumi:"signedRequestMode"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs struct {
	// Defines the request parameters that contribute to the cache key.
	// Structure is documented below.
	CacheKeyPolicy EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrInput `pulumi:"cacheKeyPolicy"`
	// Cache modes allow users to control the behaviour of the cache, what content it should cache automatically, whether to respect origin headers, or whether to unconditionally cache all responses.
	// For all cache modes, Cache-Control headers will be passed to the client. Use clientTtl to override what is sent to the client.
	// Possible values are `CACHE_ALL_STATIC`, `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `BYPASS_CACHE`.
	CacheMode pulumi.StringPtrInput `pulumi:"cacheMode"`
	// Specifies a separate client (e.g. browser client) TTL, separate from the TTL used by the edge caches. Leaving this empty will use the same cache TTL for both the CDN and the client-facing response.
	// - The TTL must be > 0 and <= 86400s (1 day)
	// - The clientTtl cannot be larger than the defaultTtl (if set)
	// - Fractions of a second are not allowed.
	//   Omit this field to use the defaultTtl, or the max-age set by the origin, as the client-facing TTL.
	//   When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
	//   A duration in seconds terminated by 's'. Example: "3s".
	ClientTtl pulumi.StringPtrInput `pulumi:"clientTtl"`
	// Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age).
	// Defaults to 3600s (1 hour).
	// - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
	// - Setting a TTL of "0" means "always revalidate" (equivalent to must-revalidate)
	// - The value of defaultTTL cannot be set to a value greater than that of maxTTL.
	// - Fractions of a second are not allowed.
	// - When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses.
	//   Note that infrequently accessed objects may be evicted from the cache before the defined TTL. Objects that expire will be revalidated with the origin.
	//   When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field.
	//   A duration in seconds terminated by 's'. Example: "3s".
	DefaultTtl pulumi.StringPtrInput `pulumi:"defaultTtl"`
	// Specifies the maximum allowed TTL for cached content served by this origin.
	// Defaults to 86400s (1 day).
	// Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTtl seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive.
	// - The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
	// - Setting a TTL of "0" means "always revalidate"
	// - The value of maxTtl must be equal to or greater than defaultTtl.
	// - Fractions of a second are not allowed.
	//   When the cache mode is set to "USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", or "BYPASS_CACHE", you must omit this field.
	//   A duration in seconds terminated by 's'. Example: "3s".
	MaxTtl pulumi.StringPtrInput `pulumi:"maxTtl"`
	// Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency.
	// By default, the CDNPolicy will apply the following default TTLs to these status codes:
	// - HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m
	// - HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s
	// - HTTP 405 (Method Not Found), 414 (URI Too Long), 501 (Not Implemented): 60s
	//   These defaults can be overridden in negativeCachingPolicy
	NegativeCaching pulumi.BoolPtrInput `pulumi:"negativeCaching"`
	// Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
	// - Omitting the policy and leaving negativeCaching enabled will use the default TTLs for each status code, defined in negativeCaching.
	// - TTLs must be >= 0 (where 0 is "always revalidate") and <= 86400s (1 day)
	//   Note that when specifying an explicit negativeCachingPolicy, you should take care to specify a cache TTL for all response codes that you wish to cache. The CDNPolicy will not apply any default negative caching when a policy exists.
	NegativeCachingPolicy pulumi.StringMapInput `pulumi:"negativeCachingPolicy"`
	// The EdgeCacheKeyset containing the set of public keys used to validate signed requests at the edge.
	SignedRequestKeyset pulumi.StringPtrInput `pulumi:"signedRequestKeyset"`
	// Whether to enforce signed requests. The default value is DISABLED, which means all content is public, and does not authorize access.
	// You must also set a signedRequestKeyset to enable signed requests.
	// When set to REQUIRE_SIGNATURES, all matching requests will have their signature validated. Requests that were not signed with the corresponding private key, or that are otherwise invalid (expired, do not match the signature, IP address, or header) will be rejected with a HTTP 403 and (if enabled) logged.
	// Possible values are `DISABLED` and `REQUIRE_SIGNATURES`.
	SignedRequestMode pulumi.StringPtrInput `pulumi:"signedRequestMode"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicy 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicy struct {
	// If true, requests to different hosts will be cached separately.
	// Note: this should only be enabled if hosts share the same origin and content. Removing the host from the cache key may inadvertently result in different objects being cached than intended, depending on which route the first user matched.
	ExcludeHost *bool `pulumi:"excludeHost"`
	// If true, exclude query string parameters from the cache key
	// If false (the default), include the query string parameters in
	// the cache key according to includeQueryParameters and
	// excludeQueryParameters. If neither includeQueryParameters nor
	// excludeQueryParameters is set, the entire query string will be
	// included.
	ExcludeQueryString *bool `pulumi:"excludeQueryString"`
	// Names of query string parameters to exclude from cache keys. All other parameters will be included.
	// Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
	ExcludedQueryParameters []string `pulumi:"excludedQueryParameters"`
	// If true, http and https requests will be cached separately.
	IncludeProtocol *bool `pulumi:"includeProtocol"`
	// Names of Cookies to include in cache keys.  The cookie name and cookie value of each cookie named will be used as part of the cache key.
	// Cookie names:
	// - must be valid RFC 6265 "cookie-name" tokens
	// - are case sensitive
	// - cannot start with "Edge-Cache-" (case insensitive)
	//   Note that specifying several cookies, and/or cookies that have a large range of values (e.g., per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
	//   You may specify up to three cookie names.
	IncludedCookieNames []string `pulumi:"includedCookieNames"`
	// Names of HTTP request headers to include in cache keys. The value of the header field will be used as part of the cache key.
	// - Header names must be valid HTTP RFC 7230 header field values.
	// - Header field names are case insensitive
	// - To include the HTTP method, use ":method"
	//   Note that specifying several headers, and/or headers that have a large range of values (e.g. per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
	IncludedHeaderNames []string `pulumi:"includedHeaderNames"`
	// Names of query string parameters to include in cache keys. All other parameters will be excluded.
	// Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
	IncludedQueryParameters []string `pulumi:"includedQueryParameters"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs struct {
	// If true, requests to different hosts will be cached separately.
	// Note: this should only be enabled if hosts share the same origin and content. Removing the host from the cache key may inadvertently result in different objects being cached than intended, depending on which route the first user matched.
	ExcludeHost pulumi.BoolPtrInput `pulumi:"excludeHost"`
	// If true, exclude query string parameters from the cache key
	// If false (the default), include the query string parameters in
	// the cache key according to includeQueryParameters and
	// excludeQueryParameters. If neither includeQueryParameters nor
	// excludeQueryParameters is set, the entire query string will be
	// included.
	ExcludeQueryString pulumi.BoolPtrInput `pulumi:"excludeQueryString"`
	// Names of query string parameters to exclude from cache keys. All other parameters will be included.
	// Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
	ExcludedQueryParameters pulumi.StringArrayInput `pulumi:"excludedQueryParameters"`
	// If true, http and https requests will be cached separately.
	IncludeProtocol pulumi.BoolPtrInput `pulumi:"includeProtocol"`
	// Names of Cookies to include in cache keys.  The cookie name and cookie value of each cookie named will be used as part of the cache key.
	// Cookie names:
	// - must be valid RFC 6265 "cookie-name" tokens
	// - are case sensitive
	// - cannot start with "Edge-Cache-" (case insensitive)
	//   Note that specifying several cookies, and/or cookies that have a large range of values (e.g., per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
	//   You may specify up to three cookie names.
	IncludedCookieNames pulumi.StringArrayInput `pulumi:"includedCookieNames"`
	// Names of HTTP request headers to include in cache keys. The value of the header field will be used as part of the cache key.
	// - Header names must be valid HTTP RFC 7230 header field values.
	// - Header field names are case insensitive
	// - To include the HTTP method, use ":method"
	//   Note that specifying several headers, and/or headers that have a large range of values (e.g. per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.
	IncludedHeaderNames pulumi.StringArrayInput `pulumi:"includedHeaderNames"`
	// Names of query string parameters to include in cache keys. All other parameters will be excluded.
	// Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.
	IncludedQueryParameters pulumi.StringArrayInput `pulumi:"includedQueryParameters"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ExcludeHost 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ExcludeHost() pulumi.BoolPtrOutput

If true, requests to different hosts will be cached separately. Note: this should only be enabled if hosts share the same origin and content. Removing the host from the cache key may inadvertently result in different objects being cached than intended, depending on which route the first user matched.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ExcludeQueryString 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ExcludeQueryString() pulumi.BoolPtrOutput

If true, exclude query string parameters from the cache key If false (the default), include the query string parameters in the cache key according to includeQueryParameters and excludeQueryParameters. If neither includeQueryParameters nor excludeQueryParameters is set, the entire query string will be included.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ExcludedQueryParameters 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ExcludedQueryParameters() pulumi.StringArrayOutput

Names of query string parameters to exclude from cache keys. All other parameters will be included. Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) IncludeProtocol 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) IncludeProtocol() pulumi.BoolPtrOutput

If true, http and https requests will be cached separately.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) IncludedCookieNames added in v6.18.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) IncludedCookieNames() pulumi.StringArrayOutput

Names of Cookies to include in cache keys. The cookie name and cookie value of each cookie named will be used as part of the cache key. Cookie names:

  • must be valid RFC 6265 "cookie-name" tokens
  • are case sensitive
  • cannot start with "Edge-Cache-" (case insensitive) Note that specifying several cookies, and/or cookies that have a large range of values (e.g., per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance. You may specify up to three cookie names.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) IncludedHeaderNames 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) IncludedHeaderNames() pulumi.StringArrayOutput

Names of HTTP request headers to include in cache keys. The value of the header field will be used as part of the cache key.

  • Header names must be valid HTTP RFC 7230 header field values.
  • Header field names are case insensitive
  • To include the HTTP method, use ":method" Note that specifying several headers, and/or headers that have a large range of values (e.g. per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) IncludedQueryParameters 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) IncludedQueryParameters() pulumi.StringArrayOutput

Names of query string parameters to include in cache keys. All other parameters will be excluded. Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtr and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtr 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) Elem 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ExcludeHost 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ExcludeHost() pulumi.BoolPtrOutput

If true, requests to different hosts will be cached separately. Note: this should only be enabled if hosts share the same origin and content. Removing the host from the cache key may inadvertently result in different objects being cached than intended, depending on which route the first user matched.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ExcludeQueryString 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ExcludeQueryString() pulumi.BoolPtrOutput

If true, exclude query string parameters from the cache key If false (the default), include the query string parameters in the cache key according to includeQueryParameters and excludeQueryParameters. If neither includeQueryParameters nor excludeQueryParameters is set, the entire query string will be included.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ExcludedQueryParameters 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ExcludedQueryParameters() pulumi.StringArrayOutput

Names of query string parameters to exclude from cache keys. All other parameters will be included. Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) IncludeProtocol 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) IncludeProtocol() pulumi.BoolPtrOutput

If true, http and https requests will be cached separately.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) IncludedCookieNames added in v6.18.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) IncludedCookieNames() pulumi.StringArrayOutput

Names of Cookies to include in cache keys. The cookie name and cookie value of each cookie named will be used as part of the cache key. Cookie names:

  • must be valid RFC 6265 "cookie-name" tokens
  • are case sensitive
  • cannot start with "Edge-Cache-" (case insensitive) Note that specifying several cookies, and/or cookies that have a large range of values (e.g., per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance. You may specify up to three cookie names.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) IncludedHeaderNames 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) IncludedHeaderNames() pulumi.StringArrayOutput

Names of HTTP request headers to include in cache keys. The value of the header field will be used as part of the cache key.

  • Header names must be valid HTTP RFC 7230 header field values.
  • Header field names are case insensitive
  • To include the HTTP method, use ":method" Note that specifying several headers, and/or headers that have a large range of values (e.g. per-user) will dramatically impact the cache hit rate, and may result in a higher eviction rate and reduced performance.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) IncludedQueryParameters 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) IncludedQueryParameters() pulumi.StringArrayOutput

Names of query string parameters to include in cache keys. All other parameters will be excluded. Either specify includedQueryParameters or excludedQueryParameters, not both. '&' and '=' will be percent encoded and not treated as delimiters.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) CacheKeyPolicy 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) CacheKeyPolicy() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput

Defines the request parameters that contribute to the cache key. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) CacheMode 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) CacheMode() pulumi.StringPtrOutput

Cache modes allow users to control the behaviour of the cache, what content it should cache automatically, whether to respect origin headers, or whether to unconditionally cache all responses. For all cache modes, Cache-Control headers will be passed to the client. Use clientTtl to override what is sent to the client. Possible values are `CACHE_ALL_STATIC`, `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `BYPASS_CACHE`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ClientTtl 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ClientTtl() pulumi.StringPtrOutput

Specifies a separate client (e.g. browser client) TTL, separate from the TTL used by the edge caches. Leaving this empty will use the same cache TTL for both the CDN and the client-facing response.

  • The TTL must be > 0 and <= 86400s (1 day)
  • The clientTtl cannot be larger than the defaultTtl (if set)
  • Fractions of a second are not allowed. Omit this field to use the defaultTtl, or the max-age set by the origin, as the client-facing TTL. When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field. A duration in seconds terminated by 's'. Example: "3s".

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) DefaultTtl 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) DefaultTtl() pulumi.StringPtrOutput

Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Defaults to 3600s (1 hour).

  • The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
  • Setting a TTL of "0" means "always revalidate" (equivalent to must-revalidate)
  • The value of defaultTTL cannot be set to a value greater than that of maxTTL.
  • Fractions of a second are not allowed.
  • When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. Note that infrequently accessed objects may be evicted from the cache before the defined TTL. Objects that expire will be revalidated with the origin. When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field. A duration in seconds terminated by 's'. Example: "3s".

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) MaxTtl 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) MaxTtl() pulumi.StringPtrOutput

Specifies the maximum allowed TTL for cached content served by this origin. Defaults to 86400s (1 day). Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTtl seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive.

  • The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
  • Setting a TTL of "0" means "always revalidate"
  • The value of maxTtl must be equal to or greater than defaultTtl.
  • Fractions of a second are not allowed. When the cache mode is set to "USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", or "BYPASS_CACHE", you must omit this field. A duration in seconds terminated by 's'. Example: "3s".

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) NegativeCaching 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) NegativeCaching() pulumi.BoolPtrOutput

Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. By default, the CDNPolicy will apply the following default TTLs to these status codes:

  • HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m
  • HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s
  • HTTP 405 (Method Not Found), 414 (URI Too Long), 501 (Not Implemented): 60s These defaults can be overridden in negativeCachingPolicy

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) NegativeCachingPolicy 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) NegativeCachingPolicy() pulumi.StringMapOutput

Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.

  • Omitting the policy and leaving negativeCaching enabled will use the default TTLs for each status code, defined in negativeCaching.
  • TTLs must be >= 0 (where 0 is "always revalidate") and <= 86400s (1 day) Note that when specifying an explicit negativeCachingPolicy, you should take care to specify a cache TTL for all response codes that you wish to cache. The CDNPolicy will not apply any default negative caching when a policy exists.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) SignedRequestKeyset 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) SignedRequestKeyset() pulumi.StringPtrOutput

The EdgeCacheKeyset containing the set of public keys used to validate signed requests at the edge.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) SignedRequestMode 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) SignedRequestMode() pulumi.StringPtrOutput

Whether to enforce signed requests. The default value is DISABLED, which means all content is public, and does not authorize access. You must also set a signedRequestKeyset to enable signed requests. When set to REQUIRE_SIGNATURES, all matching requests will have their signature validated. Requests that were not signed with the corresponding private key, or that are otherwise invalid (expired, do not match the signature, IP address, or header) will be rejected with a HTTP 403 and (if enabled) logged. Possible values are `DISABLED` and `REQUIRE_SIGNATURES`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtr and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtr 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) CacheKeyPolicy 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) CacheKeyPolicy() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyCacheKeyPolicyPtrOutput

Defines the request parameters that contribute to the cache key. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) CacheMode 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) CacheMode() pulumi.StringPtrOutput

Cache modes allow users to control the behaviour of the cache, what content it should cache automatically, whether to respect origin headers, or whether to unconditionally cache all responses. For all cache modes, Cache-Control headers will be passed to the client. Use clientTtl to override what is sent to the client. Possible values are `CACHE_ALL_STATIC`, `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, and `BYPASS_CACHE`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ClientTtl 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ClientTtl() pulumi.StringPtrOutput

Specifies a separate client (e.g. browser client) TTL, separate from the TTL used by the edge caches. Leaving this empty will use the same cache TTL for both the CDN and the client-facing response.

  • The TTL must be > 0 and <= 86400s (1 day)
  • The clientTtl cannot be larger than the defaultTtl (if set)
  • Fractions of a second are not allowed. Omit this field to use the defaultTtl, or the max-age set by the origin, as the client-facing TTL. When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field. A duration in seconds terminated by 's'. Example: "3s".

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) DefaultTtl 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) DefaultTtl() pulumi.StringPtrOutput

Specifies the default TTL for cached content served by this origin for responses that do not have an existing valid TTL (max-age or s-max-age). Defaults to 3600s (1 hour).

  • The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
  • Setting a TTL of "0" means "always revalidate" (equivalent to must-revalidate)
  • The value of defaultTTL cannot be set to a value greater than that of maxTTL.
  • Fractions of a second are not allowed.
  • When the cacheMode is set to FORCE_CACHE_ALL, the defaultTTL will overwrite the TTL set in all responses. Note that infrequently accessed objects may be evicted from the cache before the defined TTL. Objects that expire will be revalidated with the origin. When the cache mode is set to "USE_ORIGIN_HEADERS" or "BYPASS_CACHE", you must omit this field. A duration in seconds terminated by 's'. Example: "3s".

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) Elem 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) MaxTtl 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) MaxTtl() pulumi.StringPtrOutput

Specifies the maximum allowed TTL for cached content served by this origin. Defaults to 86400s (1 day). Cache directives that attempt to set a max-age or s-maxage higher than this, or an Expires header more than maxTtl seconds in the future will be capped at the value of maxTTL, as if it were the value of an s-maxage Cache-Control directive.

  • The TTL must be >= 0 and <= 31,536,000 seconds (1 year)
  • Setting a TTL of "0" means "always revalidate"
  • The value of maxTtl must be equal to or greater than defaultTtl.
  • Fractions of a second are not allowed. When the cache mode is set to "USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", or "BYPASS_CACHE", you must omit this field. A duration in seconds terminated by 's'. Example: "3s".

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) NegativeCaching 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) NegativeCaching() pulumi.BoolPtrOutput

Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects. This can reduce the load on your origin and improve end-user experience by reducing response latency. By default, the CDNPolicy will apply the following default TTLs to these status codes:

  • HTTP 300 (Multiple Choice), 301, 308 (Permanent Redirects): 10m
  • HTTP 404 (Not Found), 410 (Gone), 451 (Unavailable For Legal Reasons): 120s
  • HTTP 405 (Method Not Found), 414 (URI Too Long), 501 (Not Implemented): 60s These defaults can be overridden in negativeCachingPolicy

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) NegativeCachingPolicy 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) NegativeCachingPolicy() pulumi.StringMapOutput

Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.

  • Omitting the policy and leaving negativeCaching enabled will use the default TTLs for each status code, defined in negativeCaching.
  • TTLs must be >= 0 (where 0 is "always revalidate") and <= 86400s (1 day) Note that when specifying an explicit negativeCachingPolicy, you should take care to specify a cache TTL for all response codes that you wish to cache. The CDNPolicy will not apply any default negative caching when a policy exists.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) SignedRequestKeyset 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) SignedRequestKeyset() pulumi.StringPtrOutput

The EdgeCacheKeyset containing the set of public keys used to validate signed requests at the edge.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) SignedRequestMode 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) SignedRequestMode() pulumi.StringPtrOutput

Whether to enforce signed requests. The default value is DISABLED, which means all content is public, and does not authorize access. You must also set a signedRequestKeyset to enable signed requests. When set to REQUIRE_SIGNATURES, all matching requests will have their signature validated. Requests that were not signed with the corresponding private key, or that are otherwise invalid (expired, do not match the signature, IP address, or header) will be rejected with a HTTP 403 and (if enabled) logged. Possible values are `DISABLED` and `REQUIRE_SIGNATURES`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicy 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicy struct {
	// In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
	// This translates to the Access-Control-Allow-Credentials response header.
	AllowCredentials *bool `pulumi:"allowCredentials"`
	// Specifies the content for the Access-Control-Allow-Headers response header.
	AllowHeaders []string `pulumi:"allowHeaders"`
	// Specifies the content for the Access-Control-Allow-Methods response header.
	AllowMethods []string `pulumi:"allowMethods"`
	// Specifies the list of origins that will be allowed to do CORS requests.
	// This translates to the Access-Control-Allow-Origin response header.
	AllowOrigins []string `pulumi:"allowOrigins"`
	// If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
	Disabled *bool `pulumi:"disabled"`
	// Specifies the content for the Access-Control-Allow-Headers response header.
	ExposeHeaders []string `pulumi:"exposeHeaders"`
	// Specifies how long results of a preflight request can be cached by a client in seconds. Note that many browser clients enforce a maximum TTL of 600s (10 minutes).
	// - Setting the value to -1 forces a pre-flight check for all requests (not recommended)
	// - A maximum TTL of 86400s can be set, but note that (as above) some clients may force pre-flight checks at a more regular interval.
	// - This translates to the Access-Control-Max-Age header.
	//   A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
	MaxAge string `pulumi:"maxAge"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs struct {
	// In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
	// This translates to the Access-Control-Allow-Credentials response header.
	AllowCredentials pulumi.BoolPtrInput `pulumi:"allowCredentials"`
	// Specifies the content for the Access-Control-Allow-Headers response header.
	AllowHeaders pulumi.StringArrayInput `pulumi:"allowHeaders"`
	// Specifies the content for the Access-Control-Allow-Methods response header.
	AllowMethods pulumi.StringArrayInput `pulumi:"allowMethods"`
	// Specifies the list of origins that will be allowed to do CORS requests.
	// This translates to the Access-Control-Allow-Origin response header.
	AllowOrigins pulumi.StringArrayInput `pulumi:"allowOrigins"`
	// If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.
	Disabled pulumi.BoolPtrInput `pulumi:"disabled"`
	// Specifies the content for the Access-Control-Allow-Headers response header.
	ExposeHeaders pulumi.StringArrayInput `pulumi:"exposeHeaders"`
	// Specifies how long results of a preflight request can be cached by a client in seconds. Note that many browser clients enforce a maximum TTL of 600s (10 minutes).
	// - Setting the value to -1 forces a pre-flight check for all requests (not recommended)
	// - A maximum TTL of 86400s can be set, but note that (as above) some clients may force pre-flight checks at a more regular interval.
	// - This translates to the Access-Control-Max-Age header.
	//   A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
	MaxAge pulumi.StringInput `pulumi:"maxAge"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) AllowCredentials 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) AllowCredentials() pulumi.BoolPtrOutput

In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This translates to the Access-Control-Allow-Credentials response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) AllowHeaders 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) AllowHeaders() pulumi.StringArrayOutput

Specifies the content for the Access-Control-Allow-Headers response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) AllowMethods 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) AllowMethods() pulumi.StringArrayOutput

Specifies the content for the Access-Control-Allow-Methods response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) AllowOrigins 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) AllowOrigins() pulumi.StringArrayOutput

Specifies the list of origins that will be allowed to do CORS requests. This translates to the Access-Control-Allow-Origin response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) Disabled 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) Disabled() pulumi.BoolPtrOutput

If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ExposeHeaders 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ExposeHeaders() pulumi.StringArrayOutput

Specifies the content for the Access-Control-Allow-Headers response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) MaxAge 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) MaxAge() pulumi.StringOutput

Specifies how long results of a preflight request can be cached by a client in seconds. Note that many browser clients enforce a maximum TTL of 600s (10 minutes).

  • Setting the value to -1 forces a pre-flight check for all requests (not recommended)
  • A maximum TTL of 86400s can be set, but note that (as above) some clients may force pre-flight checks at a more regular interval.
  • This translates to the Access-Control-Max-Age header. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtr and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtr 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) AllowCredentials 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) AllowCredentials() pulumi.BoolPtrOutput

In response to a preflight request, setting this to true indicates that the actual request can include user credentials. This translates to the Access-Control-Allow-Credentials response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) AllowHeaders 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) AllowHeaders() pulumi.StringArrayOutput

Specifies the content for the Access-Control-Allow-Headers response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) AllowMethods 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) AllowMethods() pulumi.StringArrayOutput

Specifies the content for the Access-Control-Allow-Methods response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) AllowOrigins 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) AllowOrigins() pulumi.StringArrayOutput

Specifies the list of origins that will be allowed to do CORS requests. This translates to the Access-Control-Allow-Origin response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) Disabled 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) Disabled() pulumi.BoolPtrOutput

If true, specifies the CORS policy is disabled. The default value is false, which indicates that the CORS policy is in effect.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) Elem 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) ExposeHeaders 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) ExposeHeaders() pulumi.StringArrayOutput

Specifies the content for the Access-Control-Allow-Headers response header.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) MaxAge 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) MaxAge() pulumi.StringPtrOutput

Specifies how long results of a preflight request can be cached by a client in seconds. Note that many browser clients enforce a maximum TTL of 600s (10 minutes).

  • Setting the value to -1 forces a pre-flight check for all requests (not recommended)
  • A maximum TTL of 86400s can be set, but note that (as above) some clients may force pre-flight checks at a more regular interval.
  • This translates to the Access-Control-Max-Age header. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) CdnPolicy 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) CdnPolicy() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

The policy to use for defining caching and signed request behaviour for requests that match this route. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) CorsPolicy 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) CorsPolicy() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput

CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) UrlRewrite 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput) UrlRewrite() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput

The URL rewrite configuration for requests that match this route. Structure is documented below.

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtr and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtr 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) CdnPolicy 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) CdnPolicy() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

The policy to use for defining caching and signed request behaviour for requests that match this route. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) CorsPolicy 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) CorsPolicy() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCorsPolicyPtrOutput

CORSPolicy defines Cross-Origin-Resource-Sharing configuration, including which CORS response headers will be set. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) Elem 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) UrlRewrite 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionPtrOutput) UrlRewrite() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput

The URL rewrite configuration for requests that match this route. Structure is documented below.

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewrite 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewrite struct {
	// Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of hostRewrite.
	HostRewrite *string `pulumi:"hostRewrite"`
	// Prior to forwarding the request to the selected origin, the matching portion of the request's path is replaced by pathPrefixRewrite.
	PathPrefixRewrite *string `pulumi:"pathPrefixRewrite"`
	// Prior to forwarding the request to the selected origin, if the
	// request matched a pathTemplateMatch, the matching portion of the
	// request's path is replaced re-written using the pattern specified
	// by pathTemplateRewrite.
	// pathTemplateRewrite must be between 1 and 255 characters
	// (inclusive), must start with a '/', and must only use variables
	// captured by the route's pathTemplate matchers.
	// pathTemplateRewrite may only be used when all of a route's
	// MatchRules specify pathTemplate.
	// Only one of pathPrefixRewrite and pathTemplateRewrite may be
	// specified.
	PathTemplateRewrite *string `pulumi:"pathTemplateRewrite"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs struct {
	// Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of hostRewrite.
	HostRewrite pulumi.StringPtrInput `pulumi:"hostRewrite"`
	// Prior to forwarding the request to the selected origin, the matching portion of the request's path is replaced by pathPrefixRewrite.
	PathPrefixRewrite pulumi.StringPtrInput `pulumi:"pathPrefixRewrite"`
	// Prior to forwarding the request to the selected origin, if the
	// request matched a pathTemplateMatch, the matching portion of the
	// request's path is replaced re-written using the pattern specified
	// by pathTemplateRewrite.
	// pathTemplateRewrite must be between 1 and 255 characters
	// (inclusive), must start with a '/', and must only use variables
	// captured by the route's pathTemplate matchers.
	// pathTemplateRewrite may only be used when all of a route's
	// MatchRules specify pathTemplate.
	// Only one of pathPrefixRewrite and pathTemplateRewrite may be
	// specified.
	PathTemplateRewrite pulumi.StringPtrInput `pulumi:"pathTemplateRewrite"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) HostRewrite 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) HostRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of hostRewrite.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) PathPrefixRewrite 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) PathPrefixRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected origin, the matching portion of the request's path is replaced by pathPrefixRewrite.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) PathTemplateRewrite 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) PathTemplateRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected origin, if the request matched a pathTemplateMatch, the matching portion of the request's path is replaced re-written using the pattern specified by pathTemplateRewrite. pathTemplateRewrite must be between 1 and 255 characters (inclusive), must start with a '/', and must only use variables captured by the route's pathTemplate matchers. pathTemplateRewrite may only be used when all of a route's MatchRules specify pathTemplate. Only one of pathPrefixRewrite and pathTemplateRewrite may be specified.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtr and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtr 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) Elem 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewriteOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) HostRewrite 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) HostRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of hostRewrite.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) PathPrefixRewrite 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) PathPrefixRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected origin, the matching portion of the request's path is replaced by pathPrefixRewrite.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) PathTemplateRewrite 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) PathTemplateRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected origin, if the request matched a pathTemplateMatch, the matching portion of the request's path is replaced re-written using the pattern specified by pathTemplateRewrite. pathTemplateRewrite must be between 1 and 255 characters (inclusive), must start with a '/', and must only use variables captured by the route's pathTemplate matchers. pathTemplateRewrite may only be used when all of a route's MatchRules specify pathTemplate. Only one of pathPrefixRewrite and pathTemplateRewrite may be specified.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionUrlRewritePtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirect 

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirect struct {
	// The host that will be used in the redirect response instead of the one that was supplied in the request.
	HostRedirect *string `pulumi:"hostRedirect"`
	// If set to true, the URL scheme in the redirected request is set to https. If set to false, the URL scheme of the redirected request will remain the same as that of the request.
	// This can only be set if there is at least one (1) edgeSslCertificate set on the service.
	HttpsRedirect *bool `pulumi:"httpsRedirect"`
	// The path that will be used in the redirect response instead of the one that was supplied in the request.
	// pathRedirect cannot be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
	// The path value must be between 1 and 1024 characters.
	PathRedirect *string `pulumi:"pathRedirect"`
	// The prefix that replaces the prefixMatch specified in the routeRule, retaining the remaining portion of the URL before redirecting the request.
	// prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
	PrefixRedirect *string `pulumi:"prefixRedirect"`
	// The HTTP Status code to use for this RedirectAction.
	// The supported values are:
	// - `MOVED_PERMANENTLY_DEFAULT`, which is the default value and corresponds to 301.
	// - `FOUND`, which corresponds to 302.
	RedirectResponseCode *string `pulumi:"redirectResponseCode"`
	// If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request. If set to false, the query portion of the original URL is retained.
	StripQuery *bool `pulumi:"stripQuery"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs struct {
	// The host that will be used in the redirect response instead of the one that was supplied in the request.
	HostRedirect pulumi.StringPtrInput `pulumi:"hostRedirect"`
	// If set to true, the URL scheme in the redirected request is set to https. If set to false, the URL scheme of the redirected request will remain the same as that of the request.
	// This can only be set if there is at least one (1) edgeSslCertificate set on the service.
	HttpsRedirect pulumi.BoolPtrInput `pulumi:"httpsRedirect"`
	// The path that will be used in the redirect response instead of the one that was supplied in the request.
	// pathRedirect cannot be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
	// The path value must be between 1 and 1024 characters.
	PathRedirect pulumi.StringPtrInput `pulumi:"pathRedirect"`
	// The prefix that replaces the prefixMatch specified in the routeRule, retaining the remaining portion of the URL before redirecting the request.
	// prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.
	PrefixRedirect pulumi.StringPtrInput `pulumi:"prefixRedirect"`
	// The HTTP Status code to use for this RedirectAction.
	// The supported values are:
	// - `MOVED_PERMANENTLY_DEFAULT`, which is the default value and corresponds to 301.
	// - `FOUND`, which corresponds to 302.
	RedirectResponseCode pulumi.StringPtrInput `pulumi:"redirectResponseCode"`
	// If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request. If set to false, the query portion of the original URL is retained.
	StripQuery pulumi.BoolPtrInput `pulumi:"stripQuery"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutputWithContext 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) HostRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) HostRedirect() pulumi.StringPtrOutput

The host that will be used in the redirect response instead of the one that was supplied in the request.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) HttpsRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) HttpsRedirect() pulumi.BoolPtrOutput

If set to true, the URL scheme in the redirected request is set to https. If set to false, the URL scheme of the redirected request will remain the same as that of the request. This can only be set if there is at least one (1) edgeSslCertificate set on the service.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) PathRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) PathRedirect() pulumi.StringPtrOutput

The path that will be used in the redirect response instead of the one that was supplied in the request. pathRedirect cannot be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect. The path value must be between 1 and 1024 characters.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) PrefixRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) PrefixRedirect() pulumi.StringPtrOutput

The prefix that replaces the prefixMatch specified in the routeRule, retaining the remaining portion of the URL before redirecting the request. prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) RedirectResponseCode 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) RedirectResponseCode() pulumi.StringPtrOutput

The HTTP Status code to use for this RedirectAction. The supported values are: - `MOVED_PERMANENTLY_DEFAULT`, which is the default value and corresponds to 301. - `FOUND`, which corresponds to 302.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) StripQuery 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) StripQuery() pulumi.BoolPtrOutput

If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request. If set to false, the query portion of the original URL is retained.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrInput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtr and EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtr 

func EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput 

type EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) Elem 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) HostRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) HostRedirect() pulumi.StringPtrOutput

The host that will be used in the redirect response instead of the one that was supplied in the request.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) HttpsRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) HttpsRedirect() pulumi.BoolPtrOutput

If set to true, the URL scheme in the redirected request is set to https. If set to false, the URL scheme of the redirected request will remain the same as that of the request. This can only be set if there is at least one (1) edgeSslCertificate set on the service.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) PathRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) PathRedirect() pulumi.StringPtrOutput

The path that will be used in the redirect response instead of the one that was supplied in the request. pathRedirect cannot be supplied together with prefixRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect. The path value must be between 1 and 1024 characters.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) PrefixRedirect 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) PrefixRedirect() pulumi.StringPtrOutput

The prefix that replaces the prefixMatch specified in the routeRule, retaining the remaining portion of the URL before redirecting the request. prefixRedirect cannot be supplied together with pathRedirect. Supply one alone or neither. If neither is supplied, the path of the original request will be used for the redirect.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) RedirectResponseCode 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) RedirectResponseCode() pulumi.StringPtrOutput

The HTTP Status code to use for this RedirectAction. The supported values are: - `MOVED_PERMANENTLY_DEFAULT`, which is the default value and corresponds to 301. - `FOUND`, which corresponds to 302.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) StripQuery 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) StripQuery() pulumi.BoolPtrOutput

If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request. If set to false, the query portion of the original URL is retained.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleUrlRedirectPtrOutput

type EdgeCacheServiceRoutingPtrInput 

type EdgeCacheServiceRoutingPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPtrOutput() EdgeCacheServiceRoutingPtrOutput
	ToEdgeCacheServiceRoutingPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPtrOutput
}

EdgeCacheServiceRoutingPtrInput is an input type that accepts EdgeCacheServiceRoutingArgs, EdgeCacheServiceRoutingPtr and EdgeCacheServiceRoutingPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPtrInput` via: 

        EdgeCacheServiceRoutingArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPtr 

func EdgeCacheServiceRoutingPtr(v *EdgeCacheServiceRoutingArgs) EdgeCacheServiceRoutingPtrInput

type EdgeCacheServiceRoutingPtrOutput 

type EdgeCacheServiceRoutingPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPtrOutput) Elem 

func (o EdgeCacheServiceRoutingPtrOutput) Elem() EdgeCacheServiceRoutingOutput

func (EdgeCacheServiceRoutingPtrOutput) ElementType 

func (EdgeCacheServiceRoutingPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPtrOutput) HostRules 

func (o EdgeCacheServiceRoutingPtrOutput) HostRules() EdgeCacheServiceRoutingHostRuleArrayOutput

The list of hostRules to match against. These rules define which hostnames the EdgeCacheService will match against, and which route configurations apply. Structure is documented below.

func (EdgeCacheServiceRoutingPtrOutput) PathMatchers 

func (o EdgeCacheServiceRoutingPtrOutput) PathMatchers() EdgeCacheServiceRoutingPathMatcherArrayOutput

The name of the pathMatcher associated with this hostRule.

func (EdgeCacheServiceRoutingPtrOutput) ToEdgeCacheServiceRoutingPtrOutput 

func (o EdgeCacheServiceRoutingPtrOutput) ToEdgeCacheServiceRoutingPtrOutput() EdgeCacheServiceRoutingPtrOutput

func (EdgeCacheServiceRoutingPtrOutput) ToEdgeCacheServiceRoutingPtrOutputWithContext 

func (o EdgeCacheServiceRoutingPtrOutput) ToEdgeCacheServiceRoutingPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPtrOutput

type EdgeCacheServiceState 

type EdgeCacheServiceState struct {
	// A human-readable description of the resource.
	Description pulumi.StringPtrInput
	// 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.
	DisableHttp2 pulumi.BoolPtrInput
	// HTTP/3 (IETF QUIC) and Google QUIC are enabled by default.
	DisableQuic pulumi.BoolPtrInput
	// Resource URL that points at the Cloud Armor edge security policy that is applied on each request against the EdgeCacheService.
	EdgeSecurityPolicy pulumi.StringPtrInput
	// 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.
	EdgeSslCertificates pulumi.StringArrayInput
	// The IPv4 addresses associated with this service. Addresses are static for the lifetime of the service.
	Ipv4Addresses pulumi.StringArrayInput
	// The IPv6 addresses associated with this service. Addresses are static for the lifetime of the service.
	Ipv6Addresses pulumi.StringArrayInput
	// Set of label tags associated with the EdgeCache resource.
	Labels pulumi.StringMapInput
	// 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.
	LogConfig EdgeCacheServiceLogConfigPtrInput
	// The name of the query parameter to match. The query parameter must exist in the request, in the absence of which the request match fails.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// 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.
	RequireTls pulumi.BoolPtrInput
	// Defines how requests are routed, modified, cached and/or which origin content is filled from.
	// Structure is documented below.
	Routing EdgeCacheServiceRoutingPtrInput
	// 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.
	SslPolicy pulumi.StringPtrInput
}

func (EdgeCacheServiceState) ElementType 

func (EdgeCacheServiceState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.