networkservices

package
v6.62.0 Latest Latest
Warning

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

 Go to latest Published: Aug 2, 2023 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 `publicKeys` or `validationSharedKeys` (or both). The keys in `publicKeys` are checked first.
	// You may specify no more than one Google-managed public key.
	// If you specify `publicKeys`, you must specify at least one (1) key and may specify 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.
	// 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"`
	// An ordered list of shared keys to use for validating signed requests.
	// Shared keys are secret.  Ensure that only authorized users can add `validationSharedKeys` to a keyset.
	// You can rotate keys by appending (pushing) a new key to the list of `validationSharedKeys` and removing any superseded keys.
	// You must specify `publicKeys` or `validationSharedKeys` (or both). The keys in `publicKeys` are checked first.
	// Structure is documented below.
	ValidationSharedKeys EdgeCacheKeysetValidationSharedKeyArrayOutput `pulumi:"validationSharedKeys"`
}

EdgeCacheKeyset represents a collection of public keys used for validating signed requests.

To get more information about EdgeCacheKeyset, see:

* [API documentation](https://cloud.google.com/media-cdn/docs/reference/rest/v1/projects.locations.edgeCacheKeysets) * How-to Guides

> **Warning:** All arguments including the following potentially sensitive values will be stored in the raw state as plain text: `public_key.public_key.value`. Read more about sensitive data in state.

## 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
	})
}

``` ### Network Services Edge Cache Keyset Dual Token

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := secretmanager.NewSecret(ctx, "secret-basic", &secretmanager.SecretArgs{
			SecretId: pulumi.String("secret-name"),
			Replication: &secretmanager.SecretReplicationArgs{
				Automatic: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretVersion(ctx, "secret-version-basic", &secretmanager.SecretVersionArgs{
			Secret:     secret_basic.ID(),
			SecretData: pulumi.String("secret-data"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheKeyset(ctx, "default", &networkservices.EdgeCacheKeysetArgs{
			Description: pulumi.String("The default keyset"),
			PublicKeys: networkservices.EdgeCacheKeysetPublicKeyArray{
				&networkservices.EdgeCacheKeysetPublicKeyArgs{
					Id:      pulumi.String("my-public-key"),
					Managed: pulumi.Bool(true),
				},
			},
			ValidationSharedKeys: networkservices.EdgeCacheKeysetValidationSharedKeyArray{
				&networkservices.EdgeCacheKeysetValidationSharedKeyArgs{
					SecretVersion: secret_version_basic.ID(),
				},
			},
		})
		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 `publicKeys` or `validationSharedKeys` (or both). The keys in `publicKeys` are checked first.
	// You may specify no more than one Google-managed public key.
	// If you specify `publicKeys`, you must specify at least one (1) key and may specify 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.
	// 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
	// An ordered list of shared keys to use for validating signed requests.
	// Shared keys are secret.  Ensure that only authorized users can add `validationSharedKeys` to a keyset.
	// You can rotate keys by appending (pushing) a new key to the list of `validationSharedKeys` and removing any superseded keys.
	// You must specify `publicKeys` or `validationSharedKeys` (or both). The keys in `publicKeys` are checked first.
	// Structure is documented below.
	ValidationSharedKeys EdgeCacheKeysetValidationSharedKeyArrayInput
}

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 `publicKeys` or `validationSharedKeys` (or both). The keys in `publicKeys` are checked first. You may specify no more than one Google-managed public key. If you specify `publicKeys`, you must specify at least one (1) key and may specify 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. 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

func (EdgeCacheKeysetOutput) ValidationSharedKeys added in v6.44.0 

func (o EdgeCacheKeysetOutput) ValidationSharedKeys() EdgeCacheKeysetValidationSharedKeyArrayOutput

An ordered list of shared keys to use for validating signed requests. Shared keys are secret. Ensure that only authorized users can add `validationSharedKeys` to a keyset. You can rotate keys by appending (pushing) a new key to the list of `validationSharedKeys` and removing any superseded keys. You must specify `publicKeys` or `validationSharedKeys` (or both). The keys in `publicKeys` are checked first. Structure is documented below.

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"`
	// Set to true to have the CDN automatically manage this public key value.
	Managed *bool `pulumi:"managed"`
	// 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"`
	// Set to true to have the CDN automatically manage this public key value.
	Managed pulumi.BoolPtrInput `pulumi:"managed"`
	// 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.StringPtrInput `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) Managed added in v6.44.0 

func (o EdgeCacheKeysetPublicKeyOutput) Managed() pulumi.BoolPtrOutput

Set to true to have the CDN automatically manage this public key value.

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.StringPtrOutput

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 `publicKeys` or `validationSharedKeys` (or both). The keys in `publicKeys` are checked first.
	// You may specify no more than one Google-managed public key.
	// If you specify `publicKeys`, you must specify at least one (1) key and may specify 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.
	// 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
	// An ordered list of shared keys to use for validating signed requests.
	// Shared keys are secret.  Ensure that only authorized users can add `validationSharedKeys` to a keyset.
	// You can rotate keys by appending (pushing) a new key to the list of `validationSharedKeys` and removing any superseded keys.
	// You must specify `publicKeys` or `validationSharedKeys` (or both). The keys in `publicKeys` are checked first.
	// Structure is documented below.
	ValidationSharedKeys EdgeCacheKeysetValidationSharedKeyArrayInput
}

func (EdgeCacheKeysetState) ElementType 

func (EdgeCacheKeysetState) ElementType() reflect.Type

type EdgeCacheKeysetValidationSharedKey added in v6.44.0 

type EdgeCacheKeysetValidationSharedKey struct {
	// The name of the secret version in Secret Manager.
	// The resource name of the secret version must be in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the secrets themselves.
	// The secrets must be at least 16 bytes large.  The recommended secret size depends on the signature algorithm you are using.
	// * If you are using HMAC-SHA1, we suggest 20-byte secrets.
	// * If you are using HMAC-SHA256, we suggest 32-byte secrets.
	//   See RFC 2104, Section 3 for more details on these recommendations.
	SecretVersion string `pulumi:"secretVersion"`
}

type EdgeCacheKeysetValidationSharedKeyArgs added in v6.44.0 

type EdgeCacheKeysetValidationSharedKeyArgs struct {
	// The name of the secret version in Secret Manager.
	// The resource name of the secret version must be in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the secrets themselves.
	// The secrets must be at least 16 bytes large.  The recommended secret size depends on the signature algorithm you are using.
	// * If you are using HMAC-SHA1, we suggest 20-byte secrets.
	// * If you are using HMAC-SHA256, we suggest 32-byte secrets.
	//   See RFC 2104, Section 3 for more details on these recommendations.
	SecretVersion pulumi.StringInput `pulumi:"secretVersion"`
}

func (EdgeCacheKeysetValidationSharedKeyArgs) ElementType added in v6.44.0 

func (EdgeCacheKeysetValidationSharedKeyArgs) ElementType() reflect.Type

func (EdgeCacheKeysetValidationSharedKeyArgs) ToEdgeCacheKeysetValidationSharedKeyOutput added in v6.44.0 

func (i EdgeCacheKeysetValidationSharedKeyArgs) ToEdgeCacheKeysetValidationSharedKeyOutput() EdgeCacheKeysetValidationSharedKeyOutput

func (EdgeCacheKeysetValidationSharedKeyArgs) ToEdgeCacheKeysetValidationSharedKeyOutputWithContext added in v6.44.0 

func (i EdgeCacheKeysetValidationSharedKeyArgs) ToEdgeCacheKeysetValidationSharedKeyOutputWithContext(ctx context.Context) EdgeCacheKeysetValidationSharedKeyOutput

type EdgeCacheKeysetValidationSharedKeyArray added in v6.44.0 

type EdgeCacheKeysetValidationSharedKeyArray []EdgeCacheKeysetValidationSharedKeyInput

func (EdgeCacheKeysetValidationSharedKeyArray) ElementType added in v6.44.0 

func (EdgeCacheKeysetValidationSharedKeyArray) ElementType() reflect.Type

func (EdgeCacheKeysetValidationSharedKeyArray) ToEdgeCacheKeysetValidationSharedKeyArrayOutput added in v6.44.0 

func (i EdgeCacheKeysetValidationSharedKeyArray) ToEdgeCacheKeysetValidationSharedKeyArrayOutput() EdgeCacheKeysetValidationSharedKeyArrayOutput

func (EdgeCacheKeysetValidationSharedKeyArray) ToEdgeCacheKeysetValidationSharedKeyArrayOutputWithContext added in v6.44.0 

func (i EdgeCacheKeysetValidationSharedKeyArray) ToEdgeCacheKeysetValidationSharedKeyArrayOutputWithContext(ctx context.Context) EdgeCacheKeysetValidationSharedKeyArrayOutput

type EdgeCacheKeysetValidationSharedKeyArrayInput added in v6.44.0 

type EdgeCacheKeysetValidationSharedKeyArrayInput interface {
	pulumi.Input

	ToEdgeCacheKeysetValidationSharedKeyArrayOutput() EdgeCacheKeysetValidationSharedKeyArrayOutput
	ToEdgeCacheKeysetValidationSharedKeyArrayOutputWithContext(context.Context) EdgeCacheKeysetValidationSharedKeyArrayOutput
}

EdgeCacheKeysetValidationSharedKeyArrayInput is an input type that accepts EdgeCacheKeysetValidationSharedKeyArray and EdgeCacheKeysetValidationSharedKeyArrayOutput values. You can construct a concrete instance of `EdgeCacheKeysetValidationSharedKeyArrayInput` via: 

EdgeCacheKeysetValidationSharedKeyArray{ EdgeCacheKeysetValidationSharedKeyArgs{...} }

type EdgeCacheKeysetValidationSharedKeyArrayOutput added in v6.44.0 

type EdgeCacheKeysetValidationSharedKeyArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) ElementType added in v6.44.0 

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) ElementType() reflect.Type

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) Index added in v6.44.0 

func (o EdgeCacheKeysetValidationSharedKeyArrayOutput) Index(i pulumi.IntInput) EdgeCacheKeysetValidationSharedKeyOutput

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) ToEdgeCacheKeysetValidationSharedKeyArrayOutput added in v6.44.0 

func (o EdgeCacheKeysetValidationSharedKeyArrayOutput) ToEdgeCacheKeysetValidationSharedKeyArrayOutput() EdgeCacheKeysetValidationSharedKeyArrayOutput

func (EdgeCacheKeysetValidationSharedKeyArrayOutput) ToEdgeCacheKeysetValidationSharedKeyArrayOutputWithContext added in v6.44.0 

func (o EdgeCacheKeysetValidationSharedKeyArrayOutput) ToEdgeCacheKeysetValidationSharedKeyArrayOutputWithContext(ctx context.Context) EdgeCacheKeysetValidationSharedKeyArrayOutput

type EdgeCacheKeysetValidationSharedKeyInput added in v6.44.0 

type EdgeCacheKeysetValidationSharedKeyInput interface {
	pulumi.Input

	ToEdgeCacheKeysetValidationSharedKeyOutput() EdgeCacheKeysetValidationSharedKeyOutput
	ToEdgeCacheKeysetValidationSharedKeyOutputWithContext(context.Context) EdgeCacheKeysetValidationSharedKeyOutput
}

EdgeCacheKeysetValidationSharedKeyInput is an input type that accepts EdgeCacheKeysetValidationSharedKeyArgs and EdgeCacheKeysetValidationSharedKeyOutput values. You can construct a concrete instance of `EdgeCacheKeysetValidationSharedKeyInput` via: 

EdgeCacheKeysetValidationSharedKeyArgs{...}

type EdgeCacheKeysetValidationSharedKeyOutput added in v6.44.0 

type EdgeCacheKeysetValidationSharedKeyOutput struct{ *pulumi.OutputState }

func (EdgeCacheKeysetValidationSharedKeyOutput) ElementType added in v6.44.0 

func (EdgeCacheKeysetValidationSharedKeyOutput) ElementType() reflect.Type

func (EdgeCacheKeysetValidationSharedKeyOutput) SecretVersion added in v6.44.0 

func (o EdgeCacheKeysetValidationSharedKeyOutput) SecretVersion() pulumi.StringOutput

The name of the secret version in Secret Manager. The resource name of the secret version must be in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the secrets themselves. The secrets must be at least 16 bytes large. The recommended secret size depends on the signature algorithm you are using.

  • If you are using HMAC-SHA1, we suggest 20-byte secrets.
  • If you are using HMAC-SHA256, we suggest 32-byte secrets. See RFC 2104, Section 3 for more details on these recommendations.

func (EdgeCacheKeysetValidationSharedKeyOutput) ToEdgeCacheKeysetValidationSharedKeyOutput added in v6.44.0 

func (o EdgeCacheKeysetValidationSharedKeyOutput) ToEdgeCacheKeysetValidationSharedKeyOutput() EdgeCacheKeysetValidationSharedKeyOutput

func (EdgeCacheKeysetValidationSharedKeyOutput) ToEdgeCacheKeysetValidationSharedKeyOutputWithContext added in v6.44.0 

func (o EdgeCacheKeysetValidationSharedKeyOutput) ToEdgeCacheKeysetValidationSharedKeyOutputWithContext(ctx context.Context) EdgeCacheKeysetValidationSharedKeyOutput

type EdgeCacheOrigin 

type EdgeCacheOrigin struct {
	pulumi.CustomResourceState

	// Enable AWS Signature Version 4 origin authentication.
	// Structure is documented below.
	AwsV4Authentication EdgeCacheOriginAwsV4AuthenticationPtrOutput `pulumi:"awsV4Authentication"`
	// 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 override actions, including url rewrites and header
	// additions, for requests that use this origin.
	// Structure is documented below.
	OriginOverrideAction EdgeCacheOriginOriginOverrideActionPtrOutput `pulumi:"originOverrideAction"`
	// Follow redirects from this origin.
	// Structure is documented below.
	OriginRedirect EdgeCacheOriginOriginRedirectPtrOutput `pulumi:"originRedirect"`
	// 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`, `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`, `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("fallback.example.com"),
			Description:   pulumi.String("The default bucket for media edge test"),
			MaxAttempts:   pulumi.Int(3),
			Protocol:      pulumi.String("HTTP"),
			Port:          pulumi.Int(80),
			RetryConditions: pulumi.StringArray{
				pulumi.String("CONNECT_FAILURE"),
				pulumi.String("NOT_FOUND"),
				pulumi.String("HTTP_5XX"),
				pulumi.String("FORBIDDEN"),
			},
			Timeout: &networkservices.EdgeCacheOriginTimeoutArgs{
				ConnectTimeout:     pulumi.String("10s"),
				MaxAttemptsTimeout: pulumi.String("20s"),
				ResponseTimeout:    pulumi.String("60s"),
				ReadTimeout:        pulumi.String("5s"),
			},
			OriginOverrideAction: &networkservices.EdgeCacheOriginOriginOverrideActionArgs{
				UrlRewrite: &networkservices.EdgeCacheOriginOriginOverrideActionUrlRewriteArgs{
					HostRewrite: pulumi.String("example.com"),
				},
				HeaderAction: &networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionArgs{
					RequestHeadersToAdds: networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray{
						&networkservices.EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs{
							HeaderName:  pulumi.String("x-header"),
							HeaderValue: pulumi.String("value"),
							Replace:     pulumi.Bool(true),
						},
					},
				},
			},
			OriginRedirect: &networkservices.EdgeCacheOriginOriginRedirectArgs{
				RedirectConditions: pulumi.StringArray{
					pulumi.String("MOVED_PERMANENTLY"),
					pulumi.String("FOUND"),
					pulumi.String("SEE_OTHER"),
					pulumi.String("TEMPORARY_REDIRECT"),
					pulumi.String("PERMANENT_REDIRECT"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheOrigin(ctx, "default", &networkservices.EdgeCacheOriginArgs{
			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
	})
}

``` ### Network Services Edge Cache Origin V4auth

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := secretmanager.NewSecret(ctx, "secret-basic", &secretmanager.SecretArgs{
			SecretId: pulumi.String("secret-name"),
			Replication: &secretmanager.SecretReplicationArgs{
				Automatic: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretVersion(ctx, "secret-version-basic", &secretmanager.SecretVersionArgs{
			Secret:     secret_basic.ID(),
			SecretData: pulumi.String("secret-data"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewEdgeCacheOrigin(ctx, "default", &networkservices.EdgeCacheOriginArgs{
			OriginAddress: pulumi.String("gs://media-edge-default"),
			Description:   pulumi.String("The default bucket for V4 authentication"),
			AwsV4Authentication: &networkservices.EdgeCacheOriginAwsV4AuthenticationArgs{
				AccessKeyId:            pulumi.String("ACCESSKEYID"),
				SecretAccessKeyVersion: secret_version_basic.ID(),
				OriginRegion:           pulumi.String("auto"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## 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 {
	// Enable AWS Signature Version 4 origin authentication.
	// Structure is documented below.
	AwsV4Authentication EdgeCacheOriginAwsV4AuthenticationPtrInput
	// 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 override actions, including url rewrites and header
	// additions, for requests that use this origin.
	// Structure is documented below.
	OriginOverrideAction EdgeCacheOriginOriginOverrideActionPtrInput
	// Follow redirects from this origin.
	// Structure is documented below.
	OriginRedirect EdgeCacheOriginOriginRedirectPtrInput
	// 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`, `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`, `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 EdgeCacheOriginAwsV4Authentication added in v6.44.0 

type EdgeCacheOriginAwsV4Authentication struct {
	// The access key ID your origin uses to identify the key.
	AccessKeyId string `pulumi:"accessKeyId"`
	// The name of the AWS region that your origin is in.
	OriginRegion string `pulumi:"originRegion"`
	// The Secret Manager secret version of the secret access key used by your origin.
	// This is the resource name of the secret version in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the project, secret, and version you require.
	SecretAccessKeyVersion string `pulumi:"secretAccessKeyVersion"`
}

type EdgeCacheOriginAwsV4AuthenticationArgs added in v6.44.0 

type EdgeCacheOriginAwsV4AuthenticationArgs struct {
	// The access key ID your origin uses to identify the key.
	AccessKeyId pulumi.StringInput `pulumi:"accessKeyId"`
	// The name of the AWS region that your origin is in.
	OriginRegion pulumi.StringInput `pulumi:"originRegion"`
	// The Secret Manager secret version of the secret access key used by your origin.
	// This is the resource name of the secret version in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the project, secret, and version you require.
	SecretAccessKeyVersion pulumi.StringInput `pulumi:"secretAccessKeyVersion"`
}

func (EdgeCacheOriginAwsV4AuthenticationArgs) ElementType added in v6.44.0 

func (EdgeCacheOriginAwsV4AuthenticationArgs) ElementType() reflect.Type

func (EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationOutput added in v6.44.0 

func (i EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationOutput() EdgeCacheOriginAwsV4AuthenticationOutput

func (EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationOutputWithContext added in v6.44.0 

func (i EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationOutputWithContext(ctx context.Context) EdgeCacheOriginAwsV4AuthenticationOutput

func (EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput added in v6.44.0 

func (i EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput() EdgeCacheOriginAwsV4AuthenticationPtrOutput

func (EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext added in v6.44.0 

func (i EdgeCacheOriginAwsV4AuthenticationArgs) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext(ctx context.Context) EdgeCacheOriginAwsV4AuthenticationPtrOutput

type EdgeCacheOriginAwsV4AuthenticationInput added in v6.44.0 

type EdgeCacheOriginAwsV4AuthenticationInput interface {
	pulumi.Input

	ToEdgeCacheOriginAwsV4AuthenticationOutput() EdgeCacheOriginAwsV4AuthenticationOutput
	ToEdgeCacheOriginAwsV4AuthenticationOutputWithContext(context.Context) EdgeCacheOriginAwsV4AuthenticationOutput
}

EdgeCacheOriginAwsV4AuthenticationInput is an input type that accepts EdgeCacheOriginAwsV4AuthenticationArgs and EdgeCacheOriginAwsV4AuthenticationOutput values. You can construct a concrete instance of `EdgeCacheOriginAwsV4AuthenticationInput` via: 

EdgeCacheOriginAwsV4AuthenticationArgs{...}

type EdgeCacheOriginAwsV4AuthenticationOutput added in v6.44.0 

type EdgeCacheOriginAwsV4AuthenticationOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginAwsV4AuthenticationOutput) AccessKeyId added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) AccessKeyId() pulumi.StringOutput

The access key ID your origin uses to identify the key.

func (EdgeCacheOriginAwsV4AuthenticationOutput) ElementType added in v6.44.0 

func (EdgeCacheOriginAwsV4AuthenticationOutput) ElementType() reflect.Type

func (EdgeCacheOriginAwsV4AuthenticationOutput) OriginRegion added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) OriginRegion() pulumi.StringOutput

The name of the AWS region that your origin is in.

func (EdgeCacheOriginAwsV4AuthenticationOutput) SecretAccessKeyVersion added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) SecretAccessKeyVersion() pulumi.StringOutput

The Secret Manager secret version of the secret access key used by your origin. This is the resource name of the secret version in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the project, secret, and version you require.

func (EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationOutput added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationOutput() EdgeCacheOriginAwsV4AuthenticationOutput

func (EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationOutputWithContext added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationOutputWithContext(ctx context.Context) EdgeCacheOriginAwsV4AuthenticationOutput

func (EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput() EdgeCacheOriginAwsV4AuthenticationPtrOutput

func (EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext(ctx context.Context) EdgeCacheOriginAwsV4AuthenticationPtrOutput

type EdgeCacheOriginAwsV4AuthenticationPtrInput added in v6.44.0 

type EdgeCacheOriginAwsV4AuthenticationPtrInput interface {
	pulumi.Input

	ToEdgeCacheOriginAwsV4AuthenticationPtrOutput() EdgeCacheOriginAwsV4AuthenticationPtrOutput
	ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext(context.Context) EdgeCacheOriginAwsV4AuthenticationPtrOutput
}

EdgeCacheOriginAwsV4AuthenticationPtrInput is an input type that accepts EdgeCacheOriginAwsV4AuthenticationArgs, EdgeCacheOriginAwsV4AuthenticationPtr and EdgeCacheOriginAwsV4AuthenticationPtrOutput values. You can construct a concrete instance of `EdgeCacheOriginAwsV4AuthenticationPtrInput` via: 

        EdgeCacheOriginAwsV4AuthenticationArgs{...}

or:

        nil

func EdgeCacheOriginAwsV4AuthenticationPtr added in v6.44.0 

func EdgeCacheOriginAwsV4AuthenticationPtr(v *EdgeCacheOriginAwsV4AuthenticationArgs) EdgeCacheOriginAwsV4AuthenticationPtrInput

type EdgeCacheOriginAwsV4AuthenticationPtrOutput added in v6.44.0 

type EdgeCacheOriginAwsV4AuthenticationPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) AccessKeyId added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) AccessKeyId() pulumi.StringPtrOutput

The access key ID your origin uses to identify the key.

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) Elem added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) Elem() EdgeCacheOriginAwsV4AuthenticationOutput

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) ElementType added in v6.44.0 

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) OriginRegion added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) OriginRegion() pulumi.StringPtrOutput

The name of the AWS region that your origin is in.

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) SecretAccessKeyVersion added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) SecretAccessKeyVersion() pulumi.StringPtrOutput

The Secret Manager secret version of the secret access key used by your origin. This is the resource name of the secret version in the format `projects/*/secrets/*/versions/*` where the `*` values are replaced by the project, secret, and version you require.

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutput() EdgeCacheOriginAwsV4AuthenticationPtrOutput

func (EdgeCacheOriginAwsV4AuthenticationPtrOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext added in v6.44.0 

func (o EdgeCacheOriginAwsV4AuthenticationPtrOutput) ToEdgeCacheOriginAwsV4AuthenticationPtrOutputWithContext(ctx context.Context) EdgeCacheOriginAwsV4AuthenticationPtrOutput

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 EdgeCacheOriginOriginOverrideAction added in v6.45.0 

type EdgeCacheOriginOriginOverrideAction struct {
	// The header actions, including adding and removing
	// headers, for request handled by this origin.
	// Structure is documented below.
	HeaderAction *EdgeCacheOriginOriginOverrideActionHeaderAction `pulumi:"headerAction"`
	// The URL rewrite configuration for request that are
	// handled by this origin.
	// Structure is documented below.
	UrlRewrite *EdgeCacheOriginOriginOverrideActionUrlRewrite `pulumi:"urlRewrite"`
}

type EdgeCacheOriginOriginOverrideActionArgs added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionArgs struct {
	// The header actions, including adding and removing
	// headers, for request handled by this origin.
	// Structure is documented below.
	HeaderAction EdgeCacheOriginOriginOverrideActionHeaderActionPtrInput `pulumi:"headerAction"`
	// The URL rewrite configuration for request that are
	// handled by this origin.
	// Structure is documented below.
	UrlRewrite EdgeCacheOriginOriginOverrideActionUrlRewritePtrInput `pulumi:"urlRewrite"`
}

func (EdgeCacheOriginOriginOverrideActionArgs) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionOutput added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionOutput() EdgeCacheOriginOriginOverrideActionOutput

func (EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionOutput

func (EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionPtrOutput added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionPtrOutput() EdgeCacheOriginOriginOverrideActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionArgs) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionPtrOutput

type EdgeCacheOriginOriginOverrideActionHeaderAction added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderAction struct {
	// Describes a header to add.
	// You may add a maximum of 25 request headers.
	// Structure is documented below.
	RequestHeadersToAdds []EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAdd `pulumi:"requestHeadersToAdds"`
}

type EdgeCacheOriginOriginOverrideActionHeaderActionArgs added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionArgs struct {
	// Describes a header to add.
	// You may add a maximum of 25 request headers.
	// Structure is documented below.
	RequestHeadersToAdds EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayInput `pulumi:"requestHeadersToAdds"`
}

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutput added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutput() EdgeCacheOriginOriginOverrideActionHeaderActionOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

type EdgeCacheOriginOriginOverrideActionHeaderActionInput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginOverrideActionHeaderActionOutput() EdgeCacheOriginOriginOverrideActionHeaderActionOutput
	ToEdgeCacheOriginOriginOverrideActionHeaderActionOutputWithContext(context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionOutput
}

EdgeCacheOriginOriginOverrideActionHeaderActionInput is an input type that accepts EdgeCacheOriginOriginOverrideActionHeaderActionArgs and EdgeCacheOriginOriginOverrideActionHeaderActionOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginOverrideActionHeaderActionInput` via: 

EdgeCacheOriginOriginOverrideActionHeaderActionArgs{...}

type EdgeCacheOriginOriginOverrideActionHeaderActionOutput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) RequestHeadersToAdds added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionOutput) RequestHeadersToAdds() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput

Describes a header to add. You may add a maximum of 25 request headers. Structure is documented below.

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutput() EdgeCacheOriginOriginOverrideActionHeaderActionOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

type EdgeCacheOriginOriginOverrideActionHeaderActionPtrInput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionPtrInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput
	ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext(context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput
}

EdgeCacheOriginOriginOverrideActionHeaderActionPtrInput is an input type that accepts EdgeCacheOriginOriginOverrideActionHeaderActionArgs, EdgeCacheOriginOriginOverrideActionHeaderActionPtr and EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginOverrideActionHeaderActionPtrInput` via: 

        EdgeCacheOriginOriginOverrideActionHeaderActionArgs{...}

or:

        nil

func EdgeCacheOriginOriginOverrideActionHeaderActionPtr added in v6.45.0 

func EdgeCacheOriginOriginOverrideActionHeaderActionPtr(v *EdgeCacheOriginOriginOverrideActionHeaderActionArgs) EdgeCacheOriginOriginOverrideActionHeaderActionPtrInput

type EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) Elem added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) Elem() EdgeCacheOriginOriginOverrideActionHeaderActionOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) RequestHeadersToAdds added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) RequestHeadersToAdds() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput

Describes a header to add. You may add a maximum of 25 request headers. Structure is documented below.

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAdd added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAdd struct {
	// The name of the header to add.
	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.
	// By default, added header values are appended
	// to the response or request headers with the
	// same field names. The added values are
	// separated by commas.
	// To overwrite existing values, set `replace` to `true`.
	Replace *bool `pulumi:"replace"`
}

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs struct {
	// The name of the header to add.
	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.
	// By default, added header values are appended
	// to the response or request headers with the
	// same field names. The added values are
	// separated by commas.
	// To overwrite existing values, set `replace` to `true`.
	Replace pulumi.BoolPtrInput `pulumi:"replace"`
}

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray []EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddInput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayInput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput
	ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutputWithContext(context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput
}

EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayInput is an input type that accepts EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray and EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayInput` via: 

EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArray{ EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs{...} }

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) Index added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) Index(i pulumi.IntInput) EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArrayOutput

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddInput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput
	ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutputWithContext(context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput
}

EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddInput is an input type that accepts EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs and EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddInput` via: 

EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddArgs{...}

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) HeaderName added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) HeaderName() pulumi.StringOutput

The name of the header to add.

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) HeaderValue added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) HeaderValue() pulumi.StringOutput

The value of the header to add.

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) Replace added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) Replace() pulumi.BoolPtrOutput

Whether to replace all existing headers with the same name. By default, added header values are appended to the response or request headers with the same field names. The added values are separated by commas. To overwrite existing values, set `replace` to `true`.

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput() EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput

func (EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput) ToEdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionHeaderActionRequestHeadersToAddOutput

type EdgeCacheOriginOriginOverrideActionInput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginOverrideActionOutput() EdgeCacheOriginOriginOverrideActionOutput
	ToEdgeCacheOriginOriginOverrideActionOutputWithContext(context.Context) EdgeCacheOriginOriginOverrideActionOutput
}

EdgeCacheOriginOriginOverrideActionInput is an input type that accepts EdgeCacheOriginOriginOverrideActionArgs and EdgeCacheOriginOriginOverrideActionOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginOverrideActionInput` via: 

EdgeCacheOriginOriginOverrideActionArgs{...}

type EdgeCacheOriginOriginOverrideActionOutput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionOutput) HeaderAction added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionOutput) HeaderAction() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

The header actions, including adding and removing headers, for request handled by this origin. Structure is documented below.

func (EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionOutput() EdgeCacheOriginOriginOverrideActionOutput

func (EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionOutput

func (EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutput() EdgeCacheOriginOriginOverrideActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionOutput) UrlRewrite added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionOutput) UrlRewrite() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

The URL rewrite configuration for request that are handled by this origin. Structure is documented below.

type EdgeCacheOriginOriginOverrideActionPtrInput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionPtrInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginOverrideActionPtrOutput() EdgeCacheOriginOriginOverrideActionPtrOutput
	ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext(context.Context) EdgeCacheOriginOriginOverrideActionPtrOutput
}

EdgeCacheOriginOriginOverrideActionPtrInput is an input type that accepts EdgeCacheOriginOriginOverrideActionArgs, EdgeCacheOriginOriginOverrideActionPtr and EdgeCacheOriginOriginOverrideActionPtrOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginOverrideActionPtrInput` via: 

        EdgeCacheOriginOriginOverrideActionArgs{...}

or:

        nil

func EdgeCacheOriginOriginOverrideActionPtr added in v6.45.0 

func EdgeCacheOriginOriginOverrideActionPtr(v *EdgeCacheOriginOriginOverrideActionArgs) EdgeCacheOriginOriginOverrideActionPtrInput

type EdgeCacheOriginOriginOverrideActionPtrOutput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionPtrOutput) Elem added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionPtrOutput) Elem() EdgeCacheOriginOriginOverrideActionOutput

func (EdgeCacheOriginOriginOverrideActionPtrOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionPtrOutput) HeaderAction added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionPtrOutput) HeaderAction() EdgeCacheOriginOriginOverrideActionHeaderActionPtrOutput

The header actions, including adding and removing headers, for request handled by this origin. Structure is documented below.

func (EdgeCacheOriginOriginOverrideActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutput() EdgeCacheOriginOriginOverrideActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionPtrOutput) ToEdgeCacheOriginOriginOverrideActionPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionPtrOutput

func (EdgeCacheOriginOriginOverrideActionPtrOutput) UrlRewrite added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionPtrOutput) UrlRewrite() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

The URL rewrite configuration for request that are handled by this origin. Structure is documented below.

type EdgeCacheOriginOriginOverrideActionUrlRewrite added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionUrlRewrite struct {
	// Prior to forwarding the request to the selected
	// origin, the request's host header is replaced with
	// contents of the hostRewrite.
	// This value must be between 1 and 255 characters.
	HostRewrite *string `pulumi:"hostRewrite"`
}

type EdgeCacheOriginOriginOverrideActionUrlRewriteArgs added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionUrlRewriteArgs struct {
	// Prior to forwarding the request to the selected
	// origin, the request's host header is replaced with
	// contents of the hostRewrite.
	// This value must be between 1 and 255 characters.
	HostRewrite pulumi.StringPtrInput `pulumi:"hostRewrite"`
}

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutput added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutput() EdgeCacheOriginOriginOverrideActionUrlRewriteOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionUrlRewriteOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

type EdgeCacheOriginOriginOverrideActionUrlRewriteInput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionUrlRewriteInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutput() EdgeCacheOriginOriginOverrideActionUrlRewriteOutput
	ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutputWithContext(context.Context) EdgeCacheOriginOriginOverrideActionUrlRewriteOutput
}

EdgeCacheOriginOriginOverrideActionUrlRewriteInput is an input type that accepts EdgeCacheOriginOriginOverrideActionUrlRewriteArgs and EdgeCacheOriginOriginOverrideActionUrlRewriteOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginOverrideActionUrlRewriteInput` via: 

EdgeCacheOriginOriginOverrideActionUrlRewriteArgs{...}

type EdgeCacheOriginOriginOverrideActionUrlRewriteOutput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionUrlRewriteOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) HostRewrite added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) HostRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of the hostRewrite. This value must be between 1 and 255 characters.

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutput() EdgeCacheOriginOriginOverrideActionUrlRewriteOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewriteOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionUrlRewriteOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewriteOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

type EdgeCacheOriginOriginOverrideActionUrlRewritePtrInput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionUrlRewritePtrInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput
	ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext(context.Context) EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput
}

EdgeCacheOriginOriginOverrideActionUrlRewritePtrInput is an input type that accepts EdgeCacheOriginOriginOverrideActionUrlRewriteArgs, EdgeCacheOriginOriginOverrideActionUrlRewritePtr and EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginOverrideActionUrlRewritePtrInput` via: 

        EdgeCacheOriginOriginOverrideActionUrlRewriteArgs{...}

or:

        nil

func EdgeCacheOriginOriginOverrideActionUrlRewritePtr added in v6.45.0 

func EdgeCacheOriginOriginOverrideActionUrlRewritePtr(v *EdgeCacheOriginOriginOverrideActionUrlRewriteArgs) EdgeCacheOriginOriginOverrideActionUrlRewritePtrInput

type EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput added in v6.45.0 

type EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) Elem added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) Elem() EdgeCacheOriginOriginOverrideActionUrlRewriteOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) HostRewrite added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) HostRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected origin, the request's host header is replaced with contents of the hostRewrite. This value must be between 1 and 255 characters.

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput() EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

func (EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput) ToEdgeCacheOriginOriginOverrideActionUrlRewritePtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginOverrideActionUrlRewritePtrOutput

type EdgeCacheOriginOriginRedirect added in v6.45.0 

type EdgeCacheOriginOriginRedirect struct {
	// The set of redirect response codes that the CDN
	// follows. Values of
	// [RedirectConditions](https://cloud.google.com/media-cdn/docs/reference/rest/v1/projects.locations.edgeCacheOrigins#redirectconditions)
	// are accepted.
	RedirectConditions []string `pulumi:"redirectConditions"`
}

type EdgeCacheOriginOriginRedirectArgs added in v6.45.0 

type EdgeCacheOriginOriginRedirectArgs struct {
	// The set of redirect response codes that the CDN
	// follows. Values of
	// [RedirectConditions](https://cloud.google.com/media-cdn/docs/reference/rest/v1/projects.locations.edgeCacheOrigins#redirectconditions)
	// are accepted.
	RedirectConditions pulumi.StringArrayInput `pulumi:"redirectConditions"`
}

func (EdgeCacheOriginOriginRedirectArgs) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginRedirectArgs) ElementType() reflect.Type

func (EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectOutput added in v6.45.0 

func (i EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectOutput() EdgeCacheOriginOriginRedirectOutput

func (EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectOutputWithContext(ctx context.Context) EdgeCacheOriginOriginRedirectOutput

func (EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectPtrOutput added in v6.45.0 

func (i EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectPtrOutput() EdgeCacheOriginOriginRedirectPtrOutput

func (EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext added in v6.45.0 

func (i EdgeCacheOriginOriginRedirectArgs) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginRedirectPtrOutput

type EdgeCacheOriginOriginRedirectInput added in v6.45.0 

type EdgeCacheOriginOriginRedirectInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginRedirectOutput() EdgeCacheOriginOriginRedirectOutput
	ToEdgeCacheOriginOriginRedirectOutputWithContext(context.Context) EdgeCacheOriginOriginRedirectOutput
}

EdgeCacheOriginOriginRedirectInput is an input type that accepts EdgeCacheOriginOriginRedirectArgs and EdgeCacheOriginOriginRedirectOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginRedirectInput` via: 

EdgeCacheOriginOriginRedirectArgs{...}

type EdgeCacheOriginOriginRedirectOutput added in v6.45.0 

type EdgeCacheOriginOriginRedirectOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginRedirectOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginRedirectOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginRedirectOutput) RedirectConditions added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectOutput) RedirectConditions() pulumi.StringArrayOutput

The set of redirect response codes that the CDN follows. Values of [RedirectConditions](https://cloud.google.com/media-cdn/docs/reference/rest/v1/projects.locations.edgeCacheOrigins#redirectconditions) are accepted.

func (EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectOutput added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectOutput() EdgeCacheOriginOriginRedirectOutput

func (EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectOutputWithContext(ctx context.Context) EdgeCacheOriginOriginRedirectOutput

func (EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectPtrOutput added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectPtrOutput() EdgeCacheOriginOriginRedirectPtrOutput

func (EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectOutput) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginRedirectPtrOutput

type EdgeCacheOriginOriginRedirectPtrInput added in v6.45.0 

type EdgeCacheOriginOriginRedirectPtrInput interface {
	pulumi.Input

	ToEdgeCacheOriginOriginRedirectPtrOutput() EdgeCacheOriginOriginRedirectPtrOutput
	ToEdgeCacheOriginOriginRedirectPtrOutputWithContext(context.Context) EdgeCacheOriginOriginRedirectPtrOutput
}

EdgeCacheOriginOriginRedirectPtrInput is an input type that accepts EdgeCacheOriginOriginRedirectArgs, EdgeCacheOriginOriginRedirectPtr and EdgeCacheOriginOriginRedirectPtrOutput values. You can construct a concrete instance of `EdgeCacheOriginOriginRedirectPtrInput` via: 

        EdgeCacheOriginOriginRedirectArgs{...}

or:

        nil

func EdgeCacheOriginOriginRedirectPtr added in v6.45.0 

func EdgeCacheOriginOriginRedirectPtr(v *EdgeCacheOriginOriginRedirectArgs) EdgeCacheOriginOriginRedirectPtrInput

type EdgeCacheOriginOriginRedirectPtrOutput added in v6.45.0 

type EdgeCacheOriginOriginRedirectPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOriginRedirectPtrOutput) Elem added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectPtrOutput) Elem() EdgeCacheOriginOriginRedirectOutput

func (EdgeCacheOriginOriginRedirectPtrOutput) ElementType added in v6.45.0 

func (EdgeCacheOriginOriginRedirectPtrOutput) ElementType() reflect.Type

func (EdgeCacheOriginOriginRedirectPtrOutput) RedirectConditions added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectPtrOutput) RedirectConditions() pulumi.StringArrayOutput

The set of redirect response codes that the CDN follows. Values of [RedirectConditions](https://cloud.google.com/media-cdn/docs/reference/rest/v1/projects.locations.edgeCacheOrigins#redirectconditions) are accepted.

func (EdgeCacheOriginOriginRedirectPtrOutput) ToEdgeCacheOriginOriginRedirectPtrOutput added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectPtrOutput) ToEdgeCacheOriginOriginRedirectPtrOutput() EdgeCacheOriginOriginRedirectPtrOutput

func (EdgeCacheOriginOriginRedirectPtrOutput) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext added in v6.45.0 

func (o EdgeCacheOriginOriginRedirectPtrOutput) ToEdgeCacheOriginOriginRedirectPtrOutputWithContext(ctx context.Context) EdgeCacheOriginOriginRedirectPtrOutput

type EdgeCacheOriginOutput 

type EdgeCacheOriginOutput struct{ *pulumi.OutputState }

func (EdgeCacheOriginOutput) AwsV4Authentication added in v6.44.0 

func (o EdgeCacheOriginOutput) AwsV4Authentication() EdgeCacheOriginAwsV4AuthenticationPtrOutput

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

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) OriginOverrideAction added in v6.45.0 

func (o EdgeCacheOriginOutput) OriginOverrideAction() EdgeCacheOriginOriginOverrideActionPtrOutput

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

func (EdgeCacheOriginOutput) OriginRedirect added in v6.45.0 

func (o EdgeCacheOriginOutput) OriginRedirect() EdgeCacheOriginOriginRedirectPtrOutput

Follow redirects from this origin. Structure is documented below.

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`, `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`, `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 {
	// Enable AWS Signature Version 4 origin authentication.
	// Structure is documented below.
	AwsV4Authentication EdgeCacheOriginAwsV4AuthenticationPtrInput
	// 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 override actions, including url rewrites and header
	// additions, for requests that use this origin.
	// Structure is documented below.
	OriginOverrideAction EdgeCacheOriginOriginOverrideActionPtrInput
	// Follow redirects from this origin.
	// Structure is documented below.
	OriginRedirect EdgeCacheOriginOriginRedirectPtrInput
	// 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`, `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`, `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.
	//
	// <a name="nestedAwsV4Authentication"></a>The `awsV4Authentication` block supports:
	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.
	//
	// <a name="nestedAwsV4Authentication"></a>The `awsV4Authentication` block supports:
	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.

<a name="nestedAwsV4Authentication"></a>The `awsV4Authentication` block supports:

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.

<a name="nestedAwsV4Authentication"></a>The `awsV4Authentication` block supports:

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 hostRule.
	//
	// (Optional)
	// A human-readable description of the resource.
	//
	// (Optional)
	// A human-readable description of the routeRule.
	//
	// (Optional)
	// A human-readable description of the resource.
	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"`
	// 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"`
	// 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 hostRule.
	//
	// (Optional)
	// A human-readable description of the resource.
	//
	// (Optional)
	// A human-readable description of the routeRule.
	//
	// (Optional)
	// A human-readable description of the resource.
	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
	// 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
	// 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 hostRule.

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

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

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

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

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 (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 list of pathMatchers referenced via name by hostRules. PathMatcher is used to match the path portion of the URL when a HostRule matches the URL's host portion.
	// Structure is documented below.
	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 list of pathMatchers referenced via name by hostRules. PathMatcher is used to match the path portion of the URL when a HostRule matches the URL's host portion.
	// Structure is documented below.
	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 hostRule.
	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 hostRule.
	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 hostRule.

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 list of pathMatchers referenced via name by hostRules. PathMatcher is used to match the path portion of the URL when a HostRule matches the URL's host portion. Structure is documented below.

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 to which this PathMatcher is referred by the HostRule.
	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 to which this PathMatcher is referred by the HostRule.
	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 to which this PathMatcher is referred by the HostRule.

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 routeRule.
	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 routeRule.
	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 {
	// The name of the header to add.
	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 {
	// The name of the header to add.
	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

The name of the header to add.

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 {
	// The name of the header to remove.
	HeaderName string `pulumi:"headerName"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveArgs struct {
	// The name of the header to remove.
	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

The name of the header to remove.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionRequestHeaderToRemoveOutputWithContext 

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

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAdd 

type EdgeCacheServiceRoutingPathMatcherRouteRuleHeaderActionResponseHeaderToAdd struct {
	// The name of the header to add.
	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 {
	// The name of the header to add.
	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

The name of the header to add.

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"`
	// For satisfying the matchRule condition, the request's path must begin with the specified prefixMatch. prefixMatch must begin with a /.
	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"`
	// For satisfying the matchRule condition, the request's path must begin with the specified prefixMatch. prefixMatch must begin with a /.
	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 value of the header should exactly match contents of exactMatch.
	ExactMatch *string `pulumi:"exactMatch"`
	// The header name to match on.
	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"`
	// A header with the contents of headerName must exist. The match takes place whether or not the request's header has a value.
	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 value of the header should exactly match contents of exactMatch.
	ExactMatch pulumi.StringPtrInput `pulumi:"exactMatch"`
	// The header name to match on.
	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"`
	// A header with the contents of headerName must exist. The match takes place whether or not the request's header has a value.
	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 value of the header should exactly match contents of exactMatch.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) HeaderName 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleMatchRuleHeaderMatchOutput) HeaderName() pulumi.StringOutput

The header name to match on.

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

A header with the contents of headerName must exist. The match takes place whether or not the request's header has a value.

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

For satisfying the matchRule condition, the request's path must begin with the specified prefixMatch. prefixMatch must begin with a /.

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 routeRule.

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 {
	// Enable signature generation or propagation on this route.
	// This field may only be specified when signedRequestMode is set to REQUIRE_TOKENS.
	// Structure is documented below.
	AddSignatures *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignatures `pulumi:"addSignatures"`
	// 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`, `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"`
	// Limit how far into the future the expiration time of a signed request may be.
	// When set, a signed request is rejected if its expiration time is later than now + signedRequestMaximumExpirationTtl, where now is the time at which the signed request is first handled by the CDN.
	// - The TTL must be > 0.
	// - Fractions of a second are not allowed.
	//   By default, signedRequestMaximumExpirationTtl is not set and the expiration time of a signed request may be arbitrarily far into future.
	SignedRequestMaximumExpirationTtl *string `pulumi:"signedRequestMaximumExpirationTtl"`
	// 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`, `REQUIRE_SIGNATURES`, `REQUIRE_TOKENS`.
	SignedRequestMode *string `pulumi:"signedRequestMode"`
	// Additional options for signed tokens.
	// signedTokenOptions may only be specified when signedRequestMode is REQUIRE_TOKENS.
	// Structure is documented below.
	SignedTokenOptions *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptions `pulumi:"signedTokenOptions"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignatures added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignatures struct {
	// The actions to take to add signatures to responses.
	// Each value may be one of: `GENERATE_COOKIE`, `GENERATE_TOKEN_HLS_COOKIELESS`, `PROPAGATE_TOKEN_HLS_COOKIELESS`.
	Actions string `pulumi:"actions"`
	// The parameters to copy from the verified token to the generated token.
	// Only the following parameters may be copied:
	CopiedParameters []string `pulumi:"copiedParameters"`
	// The keyset to use for signature generation.
	// The following are both valid paths to an EdgeCacheKeyset resource:
	// * `projects/project/locations/global/edgeCacheKeysets/yourKeyset`
	Keyset *string `pulumi:"keyset"`
	// The query parameter in which to put the generated token.
	// If not specified, defaults to `edge-cache-token`.
	// If specified, the name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
	// This field may only be set when the GENERATE_TOKEN_HLS_COOKIELESS or PROPAGATE_TOKEN_HLS_COOKIELESS actions are specified.
	TokenQueryParameter *string `pulumi:"tokenQueryParameter"`
	// The duration the token is valid starting from the moment the token is first generated.
	// Defaults to `86400s` (1 day).
	// The TTL must be >= 0 and <= 604,800 seconds (1 week).
	// This field may only be specified when the GENERATE_COOKIE or GENERATE_TOKEN_HLS_COOKIELESS actions are specified.
	// A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
	TokenTtl *string `pulumi:"tokenTtl"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs struct {
	// The actions to take to add signatures to responses.
	// Each value may be one of: `GENERATE_COOKIE`, `GENERATE_TOKEN_HLS_COOKIELESS`, `PROPAGATE_TOKEN_HLS_COOKIELESS`.
	Actions pulumi.StringInput `pulumi:"actions"`
	// The parameters to copy from the verified token to the generated token.
	// Only the following parameters may be copied:
	CopiedParameters pulumi.StringArrayInput `pulumi:"copiedParameters"`
	// The keyset to use for signature generation.
	// The following are both valid paths to an EdgeCacheKeyset resource:
	// * `projects/project/locations/global/edgeCacheKeysets/yourKeyset`
	Keyset pulumi.StringPtrInput `pulumi:"keyset"`
	// The query parameter in which to put the generated token.
	// If not specified, defaults to `edge-cache-token`.
	// If specified, the name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
	// This field may only be set when the GENERATE_TOKEN_HLS_COOKIELESS or PROPAGATE_TOKEN_HLS_COOKIELESS actions are specified.
	TokenQueryParameter pulumi.StringPtrInput `pulumi:"tokenQueryParameter"`
	// The duration the token is valid starting from the moment the token is first generated.
	// Defaults to `86400s` (1 day).
	// The TTL must be >= 0 and <= 604,800 seconds (1 week).
	// This field may only be specified when the GENERATE_COOKIE or GENERATE_TOKEN_HLS_COOKIELESS actions are specified.
	// A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
	TokenTtl pulumi.StringPtrInput `pulumi:"tokenTtl"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ElementType added in v6.44.0 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput added in v6.44.0 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutputWithContext added in v6.44.0 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput added in v6.44.0 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext added in v6.44.0 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesInput added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) Actions added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) Actions() pulumi.StringOutput

The actions to take to add signatures to responses. Each value may be one of: `GENERATE_COOKIE`, `GENERATE_TOKEN_HLS_COOKIELESS`, `PROPAGATE_TOKEN_HLS_COOKIELESS`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) CopiedParameters added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) CopiedParameters() pulumi.StringArrayOutput

The parameters to copy from the verified token to the generated token. Only the following parameters may be copied:

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ElementType added in v6.44.0 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) Keyset added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) Keyset() pulumi.StringPtrOutput

The keyset to use for signature generation. The following are both valid paths to an EdgeCacheKeyset resource: * `projects/project/locations/global/edgeCacheKeysets/yourKeyset`

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutputWithContext added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) TokenQueryParameter added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) TokenQueryParameter() pulumi.StringPtrOutput

The query parameter in which to put the generated token. If not specified, defaults to `edge-cache-token`. If specified, the name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit. This field may only be set when the GENERATE_TOKEN_HLS_COOKIELESS or PROPAGATE_TOKEN_HLS_COOKIELESS actions are specified.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) TokenTtl added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput) TokenTtl() pulumi.StringPtrOutput

The duration the token is valid starting from the moment the token is first generated. Defaults to `86400s` (1 day). The TTL must be >= 0 and <= 604,800 seconds (1 week). This field may only be specified when the GENERATE_COOKIE or GENERATE_TOKEN_HLS_COOKIELESS actions are specified. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrInput added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtr and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtr added in v6.44.0 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Actions added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Actions() pulumi.StringPtrOutput

The actions to take to add signatures to responses. Each value may be one of: `GENERATE_COOKIE`, `GENERATE_TOKEN_HLS_COOKIELESS`, `PROPAGATE_TOKEN_HLS_COOKIELESS`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) CopiedParameters added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) CopiedParameters() pulumi.StringArrayOutput

The parameters to copy from the verified token to the generated token. Only the following parameters may be copied:

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Elem added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ElementType added in v6.44.0 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Keyset added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) Keyset() pulumi.StringPtrOutput

The keyset to use for signature generation. The following are both valid paths to an EdgeCacheKeyset resource: * `projects/project/locations/global/edgeCacheKeysets/yourKeyset`

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) TokenQueryParameter added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) TokenQueryParameter() pulumi.StringPtrOutput

The query parameter in which to put the generated token. If not specified, defaults to `edge-cache-token`. If specified, the name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit. This field may only be set when the GENERATE_TOKEN_HLS_COOKIELESS or PROPAGATE_TOKEN_HLS_COOKIELESS actions are specified.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) TokenTtl added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput) TokenTtl() pulumi.StringPtrOutput

The duration the token is valid starting from the moment the token is first generated. Defaults to `86400s` (1 day). The TTL must be >= 0 and <= 604,800 seconds (1 week). This field may only be specified when the GENERATE_COOKIE or GENERATE_TOKEN_HLS_COOKIELESS actions are specified. A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyArgs struct {
	// Enable signature generation or propagation on this route.
	// This field may only be specified when signedRequestMode is set to REQUIRE_TOKENS.
	// Structure is documented below.
	AddSignatures EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrInput `pulumi:"addSignatures"`
	// 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`, `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"`
	// Limit how far into the future the expiration time of a signed request may be.
	// When set, a signed request is rejected if its expiration time is later than now + signedRequestMaximumExpirationTtl, where now is the time at which the signed request is first handled by the CDN.
	// - The TTL must be > 0.
	// - Fractions of a second are not allowed.
	//   By default, signedRequestMaximumExpirationTtl is not set and the expiration time of a signed request may be arbitrarily far into future.
	SignedRequestMaximumExpirationTtl pulumi.StringPtrInput `pulumi:"signedRequestMaximumExpirationTtl"`
	// 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`, `REQUIRE_SIGNATURES`, `REQUIRE_TOKENS`.
	SignedRequestMode pulumi.StringPtrInput `pulumi:"signedRequestMode"`
	// Additional options for signed tokens.
	// signedTokenOptions may only be specified when signedRequestMode is REQUIRE_TOKENS.
	// Structure is documented below.
	SignedTokenOptions EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrInput `pulumi:"signedTokenOptions"`
}

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) AddSignatures added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) AddSignatures() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

Enable signature generation or propagation on this route. This field may only be specified when signedRequestMode is set to REQUIRE_TOKENS. Structure is documented below.

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`, `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) SignedRequestMaximumExpirationTtl added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) SignedRequestMaximumExpirationTtl() pulumi.StringPtrOutput

Limit how far into the future the expiration time of a signed request may be. When set, a signed request is rejected if its expiration time is later than now + signedRequestMaximumExpirationTtl, where now is the time at which the signed request is first handled by the CDN.

  • The TTL must be > 0.
  • Fractions of a second are not allowed. By default, signedRequestMaximumExpirationTtl is not set and the expiration time of a signed request may be arbitrarily far into future.

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`, `REQUIRE_SIGNATURES`, `REQUIRE_TOKENS`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) SignedTokenOptions added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyOutput) SignedTokenOptions() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

Additional options for signed tokens. signedTokenOptions may only be specified when signedRequestMode is REQUIRE_TOKENS. Structure is documented below.

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) AddSignatures added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) AddSignatures() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyAddSignaturesPtrOutput

Enable signature generation or propagation on this route. This field may only be specified when signedRequestMode is set to REQUIRE_TOKENS. Structure is documented below.

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`, `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) SignedRequestMaximumExpirationTtl added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) SignedRequestMaximumExpirationTtl() pulumi.StringPtrOutput

Limit how far into the future the expiration time of a signed request may be. When set, a signed request is rejected if its expiration time is later than now + signedRequestMaximumExpirationTtl, where now is the time at which the signed request is first handled by the CDN.

  • The TTL must be > 0.
  • Fractions of a second are not allowed. By default, signedRequestMaximumExpirationTtl is not set and the expiration time of a signed request may be arbitrarily far into future.

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`, `REQUIRE_SIGNATURES`, `REQUIRE_TOKENS`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) SignedTokenOptions added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) SignedTokenOptions() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

Additional options for signed tokens. signedTokenOptions may only be specified when signedRequestMode is REQUIRE_TOKENS. Structure is documented below.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicyPtrOutputWithContext 

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

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptions added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptions struct {
	// The allowed signature algorithms to use.
	// Defaults to using only ED25519.
	// You may specify up to 3 signature algorithms to use.
	// Each value may be one of: `ED25519`, `HMAC_SHA_256`, `HMAC_SHA1`.
	AllowedSignatureAlgorithms []string `pulumi:"allowedSignatureAlgorithms"`
	// The query parameter in which to find the token.
	// The name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
	// Defaults to `edge-cache-token`.
	TokenQueryParameter *string `pulumi:"tokenQueryParameter"`
}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs struct {
	// The allowed signature algorithms to use.
	// Defaults to using only ED25519.
	// You may specify up to 3 signature algorithms to use.
	// Each value may be one of: `ED25519`, `HMAC_SHA_256`, `HMAC_SHA1`.
	AllowedSignatureAlgorithms pulumi.StringArrayInput `pulumi:"allowedSignatureAlgorithms"`
	// The query parameter in which to find the token.
	// The name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit.
	// Defaults to `edge-cache-token`.
	TokenQueryParameter pulumi.StringPtrInput `pulumi:"tokenQueryParameter"`
}

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ElementType added in v6.44.0 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput added in v6.44.0 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutputWithContext added in v6.44.0 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput added in v6.44.0 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext added in v6.44.0 

func (i EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsInput added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsInput` via: 

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs{...}

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) AllowedSignatureAlgorithms added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) AllowedSignatureAlgorithms() pulumi.StringArrayOutput

The allowed signature algorithms to use. Defaults to using only ED25519. You may specify up to 3 signature algorithms to use. Each value may be one of: `ED25519`, `HMAC_SHA_256`, `HMAC_SHA1`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ElementType added in v6.44.0 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutputWithContext added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) TokenQueryParameter added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput) TokenQueryParameter() pulumi.StringPtrOutput

The query parameter in which to find the token. The name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit. Defaults to `edge-cache-token`.

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrInput added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrInput interface {
	pulumi.Input

	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput
	ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext(context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput
}

EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrInput is an input type that accepts EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs, EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtr and EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput values. You can construct a concrete instance of `EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrInput` via: 

        EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs{...}

or:

        nil

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtr added in v6.44.0 

func EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtr(v *EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsArgs) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrInput

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput added in v6.44.0 

type EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput struct{ *pulumi.OutputState }

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) AllowedSignatureAlgorithms added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) AllowedSignatureAlgorithms() pulumi.StringArrayOutput

The allowed signature algorithms to use. Defaults to using only ED25519. You may specify up to 3 signature algorithms to use. Each value may be one of: `ED25519`, `HMAC_SHA_256`, `HMAC_SHA1`.

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) Elem added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) Elem() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ElementType added in v6.44.0 

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ElementType() reflect.Type

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput() EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) ToEdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutputWithContext(ctx context.Context) EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput

func (EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) TokenQueryParameter added in v6.44.0 

func (o EdgeCacheServiceRoutingPathMatcherRouteRuleRouteActionCdnPolicySignedTokenOptionsPtrOutput) TokenQueryParameter() pulumi.StringPtrOutput

The query parameter in which to find the token. The name must be 1-64 characters long and match the regular expression `a-zA-Z*` which means the first character must be a letter, and all following characters must be a dash, underscore, letter or digit. Defaults to `edge-cache-token`.

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:
	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:
	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:

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:

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 list of pathMatchers referenced via name by hostRules. PathMatcher is used to match the path portion of the URL when a HostRule matches the URL's host portion. Structure is documented below.

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 hostRule.
	//
	// (Optional)
	// A human-readable description of the resource.
	//
	// (Optional)
	// A human-readable description of the routeRule.
	//
	// (Optional)
	// A human-readable description of the resource.
	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
	// 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
	// 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

type EndpointPolicy added in v6.56.0 

type EndpointPolicy struct {
	pulumi.CustomResourceState

	// This field specifies the URL of AuthorizationPolicy resource that applies authorization policies to the inbound traffic at the matched endpoints.
	AuthorizationPolicy pulumi.StringPtrOutput `pulumi:"authorizationPolicy"`
	// A URL referring to a ClientTlsPolicy resource. ClientTlsPolicy can be set to specify the authentication for traffic from the proxy to the actual endpoints.
	ClientTlsPolicy pulumi.StringPtrOutput `pulumi:"clientTlsPolicy"`
	// Time the TcpRoute was created in UTC.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Required. A matcher that selects endpoints to which the policies should be applied.
	// Structure is documented below.
	EndpointMatcher EndpointPolicyEndpointMatcherOutput `pulumi:"endpointMatcher"`
	// Set of label tags associated with the TcpRoute resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Name of the EndpointPolicy resource.
	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"`
	// A URL referring to ServerTlsPolicy resource. ServerTlsPolicy is used to determine the authentication policy to be applied to terminate the inbound traffic at the identified backends.
	ServerTlsPolicy pulumi.StringPtrOutput `pulumi:"serverTlsPolicy"`
	// Port selector for the (matched) endpoints. If no port selector is provided, the matched config is applied to all ports.
	// Structure is documented below.
	TrafficPortSelector EndpointPolicyTrafficPortSelectorPtrOutput `pulumi:"trafficPortSelector"`
	// The type of endpoint policy. This is primarily used to validate the configuration.
	// Possible values are: `SIDECAR_PROXY`, `GRPC_SERVER`.
	Type pulumi.StringOutput `pulumi:"type"`
	// Time the TcpRoute was updated in UTC.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

## Example Usage ### Network Services Endpoint Policy 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.NewEndpointPolicy(ctx, "default", &networkservices.EndpointPolicyArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Type:        pulumi.String("SIDECAR_PROXY"),
			TrafficPortSelector: &networkservices.EndpointPolicyTrafficPortSelectorArgs{
				Ports: pulumi.StringArray{
					pulumi.String("8081"),
				},
			},
			EndpointMatcher: &networkservices.EndpointPolicyEndpointMatcherArgs{
				MetadataLabelMatcher: &networkservices.EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs{
					MetadataLabelMatchCriteria: pulumi.String("MATCH_ANY"),
					MetadataLabels: networkservices.EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray{
						&networkservices.EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs{
							LabelName:  pulumi.String("foo"),
							LabelValue: pulumi.String("bar"),
						},
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Endpoint Policy Empty Match

```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.NewEndpointPolicy(ctx, "default", &networkservices.EndpointPolicyArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Type:        pulumi.String("SIDECAR_PROXY"),
			TrafficPortSelector: &networkservices.EndpointPolicyTrafficPortSelectorArgs{
				Ports: pulumi.StringArray{
					pulumi.String("8081"),
				},
			},
			EndpointMatcher: &networkservices.EndpointPolicyEndpointMatcherArgs{
				MetadataLabelMatcher: &networkservices.EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs{
					MetadataLabelMatchCriteria: pulumi.String("MATCH_ANY"),
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

EndpointPolicy can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/endpointPolicy:EndpointPolicy default projects/{{project}}/locations/global/endpointPolicies/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/endpointPolicy:EndpointPolicy default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/endpointPolicy:EndpointPolicy default {{name}}

```

func GetEndpointPolicy added in v6.56.0 

func GetEndpointPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *EndpointPolicyState, opts ...pulumi.ResourceOption) (*EndpointPolicy, error)

GetEndpointPolicy gets an existing EndpointPolicy 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 NewEndpointPolicy added in v6.56.0 

func NewEndpointPolicy(ctx *pulumi.Context,
	name string, args *EndpointPolicyArgs, opts ...pulumi.ResourceOption) (*EndpointPolicy, error)

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

func (*EndpointPolicy) ElementType added in v6.56.0 

func (*EndpointPolicy) ElementType() reflect.Type

func (*EndpointPolicy) ToEndpointPolicyOutput added in v6.56.0 

func (i *EndpointPolicy) ToEndpointPolicyOutput() EndpointPolicyOutput

func (*EndpointPolicy) ToEndpointPolicyOutputWithContext added in v6.56.0 

func (i *EndpointPolicy) ToEndpointPolicyOutputWithContext(ctx context.Context) EndpointPolicyOutput

type EndpointPolicyArgs added in v6.56.0 

type EndpointPolicyArgs struct {
	// This field specifies the URL of AuthorizationPolicy resource that applies authorization policies to the inbound traffic at the matched endpoints.
	AuthorizationPolicy pulumi.StringPtrInput
	// A URL referring to a ClientTlsPolicy resource. ClientTlsPolicy can be set to specify the authentication for traffic from the proxy to the actual endpoints.
	ClientTlsPolicy pulumi.StringPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Required. A matcher that selects endpoints to which the policies should be applied.
	// Structure is documented below.
	EndpointMatcher EndpointPolicyEndpointMatcherInput
	// Set of label tags associated with the TcpRoute resource.
	Labels pulumi.StringMapInput
	// Name of the EndpointPolicy resource.
	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
	// A URL referring to ServerTlsPolicy resource. ServerTlsPolicy is used to determine the authentication policy to be applied to terminate the inbound traffic at the identified backends.
	ServerTlsPolicy pulumi.StringPtrInput
	// Port selector for the (matched) endpoints. If no port selector is provided, the matched config is applied to all ports.
	// Structure is documented below.
	TrafficPortSelector EndpointPolicyTrafficPortSelectorPtrInput
	// The type of endpoint policy. This is primarily used to validate the configuration.
	// Possible values are: `SIDECAR_PROXY`, `GRPC_SERVER`.
	Type pulumi.StringInput
}

The set of arguments for constructing a EndpointPolicy resource.

func (EndpointPolicyArgs) ElementType added in v6.56.0 

func (EndpointPolicyArgs) ElementType() reflect.Type

type EndpointPolicyArray added in v6.56.0 

type EndpointPolicyArray []EndpointPolicyInput

func (EndpointPolicyArray) ElementType added in v6.56.0 

func (EndpointPolicyArray) ElementType() reflect.Type

func (EndpointPolicyArray) ToEndpointPolicyArrayOutput added in v6.56.0 

func (i EndpointPolicyArray) ToEndpointPolicyArrayOutput() EndpointPolicyArrayOutput

func (EndpointPolicyArray) ToEndpointPolicyArrayOutputWithContext added in v6.56.0 

func (i EndpointPolicyArray) ToEndpointPolicyArrayOutputWithContext(ctx context.Context) EndpointPolicyArrayOutput

type EndpointPolicyArrayInput added in v6.56.0 

type EndpointPolicyArrayInput interface {
	pulumi.Input

	ToEndpointPolicyArrayOutput() EndpointPolicyArrayOutput
	ToEndpointPolicyArrayOutputWithContext(context.Context) EndpointPolicyArrayOutput
}

EndpointPolicyArrayInput is an input type that accepts EndpointPolicyArray and EndpointPolicyArrayOutput values. You can construct a concrete instance of `EndpointPolicyArrayInput` via: 

EndpointPolicyArray{ EndpointPolicyArgs{...} }

type EndpointPolicyArrayOutput added in v6.56.0 

type EndpointPolicyArrayOutput struct{ *pulumi.OutputState }

func (EndpointPolicyArrayOutput) ElementType added in v6.56.0 

func (EndpointPolicyArrayOutput) ElementType() reflect.Type

func (EndpointPolicyArrayOutput) Index added in v6.56.0 

func (o EndpointPolicyArrayOutput) Index(i pulumi.IntInput) EndpointPolicyOutput

func (EndpointPolicyArrayOutput) ToEndpointPolicyArrayOutput added in v6.56.0 

func (o EndpointPolicyArrayOutput) ToEndpointPolicyArrayOutput() EndpointPolicyArrayOutput

func (EndpointPolicyArrayOutput) ToEndpointPolicyArrayOutputWithContext added in v6.56.0 

func (o EndpointPolicyArrayOutput) ToEndpointPolicyArrayOutputWithContext(ctx context.Context) EndpointPolicyArrayOutput

type EndpointPolicyEndpointMatcher added in v6.56.0 

type EndpointPolicyEndpointMatcher struct {
	// The matcher is based on node metadata presented by xDS clients.
	// Structure is documented below.
	MetadataLabelMatcher EndpointPolicyEndpointMatcherMetadataLabelMatcher `pulumi:"metadataLabelMatcher"`
}

type EndpointPolicyEndpointMatcherArgs added in v6.56.0 

type EndpointPolicyEndpointMatcherArgs struct {
	// The matcher is based on node metadata presented by xDS clients.
	// Structure is documented below.
	MetadataLabelMatcher EndpointPolicyEndpointMatcherMetadataLabelMatcherInput `pulumi:"metadataLabelMatcher"`
}

func (EndpointPolicyEndpointMatcherArgs) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherArgs) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherOutput added in v6.56.0 

func (i EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherOutput() EndpointPolicyEndpointMatcherOutput

func (EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherOutputWithContext added in v6.56.0 

func (i EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherOutput

func (EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherPtrOutput added in v6.56.0 

func (i EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherPtrOutput() EndpointPolicyEndpointMatcherPtrOutput

func (EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherPtrOutputWithContext added in v6.56.0 

func (i EndpointPolicyEndpointMatcherArgs) ToEndpointPolicyEndpointMatcherPtrOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherPtrOutput

type EndpointPolicyEndpointMatcherInput added in v6.56.0 

type EndpointPolicyEndpointMatcherInput interface {
	pulumi.Input

	ToEndpointPolicyEndpointMatcherOutput() EndpointPolicyEndpointMatcherOutput
	ToEndpointPolicyEndpointMatcherOutputWithContext(context.Context) EndpointPolicyEndpointMatcherOutput
}

EndpointPolicyEndpointMatcherInput is an input type that accepts EndpointPolicyEndpointMatcherArgs and EndpointPolicyEndpointMatcherOutput values. You can construct a concrete instance of `EndpointPolicyEndpointMatcherInput` via: 

EndpointPolicyEndpointMatcherArgs{...}

type EndpointPolicyEndpointMatcherMetadataLabelMatcher added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcher struct {
	// Specifies how matching should be done.
	// Possible values are: `MATCH_ANY`, `MATCH_ALL`.
	MetadataLabelMatchCriteria string `pulumi:"metadataLabelMatchCriteria"`
	// The list of label value pairs that must match labels in the provided metadata based on filterMatchCriteria
	// Structure is documented below.
	MetadataLabels []EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabel `pulumi:"metadataLabels"`
}

type EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs struct {
	// Specifies how matching should be done.
	// Possible values are: `MATCH_ANY`, `MATCH_ALL`.
	MetadataLabelMatchCriteria pulumi.StringInput `pulumi:"metadataLabelMatchCriteria"`
	// The list of label value pairs that must match labels in the provided metadata based on filterMatchCriteria
	// Structure is documented below.
	MetadataLabels EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayInput `pulumi:"metadataLabels"`
}

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutput added in v6.56.0 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutputWithContext added in v6.56.0 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput added in v6.56.0 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext added in v6.56.0 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

type EndpointPolicyEndpointMatcherMetadataLabelMatcherInput added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherInput interface {
	pulumi.Input

	ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput
	ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutputWithContext(context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput
}

EndpointPolicyEndpointMatcherMetadataLabelMatcherInput is an input type that accepts EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs and EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput values. You can construct a concrete instance of `EndpointPolicyEndpointMatcherMetadataLabelMatcherInput` via: 

EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs{...}

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabel added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabel struct {
	// Required. Label name presented as key in xDS Node Metadata.
	LabelName string `pulumi:"labelName"`
	// Required. Label value presented as value corresponding to the above key, in xDS Node Metadata.
	//
	// ***
	LabelValue string `pulumi:"labelValue"`
}

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs struct {
	// Required. Label name presented as key in xDS Node Metadata.
	LabelName pulumi.StringInput `pulumi:"labelName"`
	// Required. Label value presented as value corresponding to the above key, in xDS Node Metadata.
	//
	// ***
	LabelValue pulumi.StringInput `pulumi:"labelValue"`
}

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput added in v6.56.0 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutputWithContext added in v6.56.0 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray []EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelInput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput added in v6.56.0 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutputWithContext added in v6.56.0 

func (i EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayInput added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayInput interface {
	pulumi.Input

	ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput
	ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutputWithContext(context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput
}

EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayInput is an input type that accepts EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray and EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput values. You can construct a concrete instance of `EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayInput` via: 

EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArray{ EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs{...} }

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) Index added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) Index(i pulumi.IntInput) EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutputWithContext added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelInput added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelInput interface {
	pulumi.Input

	ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput
	ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutputWithContext(context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput
}

EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelInput is an input type that accepts EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs and EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput values. You can construct a concrete instance of `EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelInput` via: 

EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArgs{...}

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) LabelName added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) LabelName() pulumi.StringOutput

Required. Label name presented as key in xDS Node Metadata.

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) LabelValue added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) LabelValue() pulumi.StringOutput

Required. Label value presented as value corresponding to the above key, in xDS Node Metadata.

***

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutputWithContext added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelOutput

type EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) MetadataLabelMatchCriteria added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) MetadataLabelMatchCriteria() pulumi.StringOutput

Specifies how matching should be done. Possible values are: `MATCH_ANY`, `MATCH_ALL`.

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) MetadataLabels added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) MetadataLabels() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput

The list of label value pairs that must match labels in the provided metadata based on filterMatchCriteria Structure is documented below.

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutput added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutputWithContext added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

type EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrInput added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrInput interface {
	pulumi.Input

	ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput
	ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext(context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput
}

EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrInput is an input type that accepts EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs, EndpointPolicyEndpointMatcherMetadataLabelMatcherPtr and EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput values. You can construct a concrete instance of `EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrInput` via: 

        EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs{...}

or:

        nil

func EndpointPolicyEndpointMatcherMetadataLabelMatcherPtr added in v6.56.0 

func EndpointPolicyEndpointMatcherMetadataLabelMatcherPtr(v *EndpointPolicyEndpointMatcherMetadataLabelMatcherArgs) EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrInput

type EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput added in v6.56.0 

type EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) Elem added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) Elem() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) MetadataLabelMatchCriteria added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) MetadataLabelMatchCriteria() pulumi.StringPtrOutput

Specifies how matching should be done. Possible values are: `MATCH_ANY`, `MATCH_ALL`.

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) MetadataLabels added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) MetadataLabels() EndpointPolicyEndpointMatcherMetadataLabelMatcherMetadataLabelArrayOutput

The list of label value pairs that must match labels in the provided metadata based on filterMatchCriteria Structure is documented below.

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

func (EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext added in v6.56.0 

func (o EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput) ToEndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

type EndpointPolicyEndpointMatcherOutput added in v6.56.0 

type EndpointPolicyEndpointMatcherOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherOutput) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherOutput) MetadataLabelMatcher added in v6.56.0 

func (o EndpointPolicyEndpointMatcherOutput) MetadataLabelMatcher() EndpointPolicyEndpointMatcherMetadataLabelMatcherOutput

The matcher is based on node metadata presented by xDS clients. Structure is documented below.

func (EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherOutput added in v6.56.0 

func (o EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherOutput() EndpointPolicyEndpointMatcherOutput

func (EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherOutputWithContext added in v6.56.0 

func (o EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherOutput

func (EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherPtrOutput added in v6.56.0 

func (o EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherPtrOutput() EndpointPolicyEndpointMatcherPtrOutput

func (EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherPtrOutputWithContext added in v6.56.0 

func (o EndpointPolicyEndpointMatcherOutput) ToEndpointPolicyEndpointMatcherPtrOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherPtrOutput

type EndpointPolicyEndpointMatcherPtrInput added in v6.56.0 

type EndpointPolicyEndpointMatcherPtrInput interface {
	pulumi.Input

	ToEndpointPolicyEndpointMatcherPtrOutput() EndpointPolicyEndpointMatcherPtrOutput
	ToEndpointPolicyEndpointMatcherPtrOutputWithContext(context.Context) EndpointPolicyEndpointMatcherPtrOutput
}

EndpointPolicyEndpointMatcherPtrInput is an input type that accepts EndpointPolicyEndpointMatcherArgs, EndpointPolicyEndpointMatcherPtr and EndpointPolicyEndpointMatcherPtrOutput values. You can construct a concrete instance of `EndpointPolicyEndpointMatcherPtrInput` via: 

        EndpointPolicyEndpointMatcherArgs{...}

or:

        nil

func EndpointPolicyEndpointMatcherPtr added in v6.56.0 

func EndpointPolicyEndpointMatcherPtr(v *EndpointPolicyEndpointMatcherArgs) EndpointPolicyEndpointMatcherPtrInput

type EndpointPolicyEndpointMatcherPtrOutput added in v6.56.0 

type EndpointPolicyEndpointMatcherPtrOutput struct{ *pulumi.OutputState }

func (EndpointPolicyEndpointMatcherPtrOutput) Elem added in v6.56.0 

func (o EndpointPolicyEndpointMatcherPtrOutput) Elem() EndpointPolicyEndpointMatcherOutput

func (EndpointPolicyEndpointMatcherPtrOutput) ElementType added in v6.56.0 

func (EndpointPolicyEndpointMatcherPtrOutput) ElementType() reflect.Type

func (EndpointPolicyEndpointMatcherPtrOutput) MetadataLabelMatcher added in v6.56.0 

func (o EndpointPolicyEndpointMatcherPtrOutput) MetadataLabelMatcher() EndpointPolicyEndpointMatcherMetadataLabelMatcherPtrOutput

The matcher is based on node metadata presented by xDS clients. Structure is documented below.

func (EndpointPolicyEndpointMatcherPtrOutput) ToEndpointPolicyEndpointMatcherPtrOutput added in v6.56.0 

func (o EndpointPolicyEndpointMatcherPtrOutput) ToEndpointPolicyEndpointMatcherPtrOutput() EndpointPolicyEndpointMatcherPtrOutput

func (EndpointPolicyEndpointMatcherPtrOutput) ToEndpointPolicyEndpointMatcherPtrOutputWithContext added in v6.56.0 

func (o EndpointPolicyEndpointMatcherPtrOutput) ToEndpointPolicyEndpointMatcherPtrOutputWithContext(ctx context.Context) EndpointPolicyEndpointMatcherPtrOutput

type EndpointPolicyInput added in v6.56.0 

type EndpointPolicyInput interface {
	pulumi.Input

	ToEndpointPolicyOutput() EndpointPolicyOutput
	ToEndpointPolicyOutputWithContext(ctx context.Context) EndpointPolicyOutput
}

type EndpointPolicyMap added in v6.56.0 

type EndpointPolicyMap map[string]EndpointPolicyInput

func (EndpointPolicyMap) ElementType added in v6.56.0 

func (EndpointPolicyMap) ElementType() reflect.Type

func (EndpointPolicyMap) ToEndpointPolicyMapOutput added in v6.56.0 

func (i EndpointPolicyMap) ToEndpointPolicyMapOutput() EndpointPolicyMapOutput

func (EndpointPolicyMap) ToEndpointPolicyMapOutputWithContext added in v6.56.0 

func (i EndpointPolicyMap) ToEndpointPolicyMapOutputWithContext(ctx context.Context) EndpointPolicyMapOutput

type EndpointPolicyMapInput added in v6.56.0 

type EndpointPolicyMapInput interface {
	pulumi.Input

	ToEndpointPolicyMapOutput() EndpointPolicyMapOutput
	ToEndpointPolicyMapOutputWithContext(context.Context) EndpointPolicyMapOutput
}

EndpointPolicyMapInput is an input type that accepts EndpointPolicyMap and EndpointPolicyMapOutput values. You can construct a concrete instance of `EndpointPolicyMapInput` via: 

EndpointPolicyMap{ "key": EndpointPolicyArgs{...} }

type EndpointPolicyMapOutput added in v6.56.0 

type EndpointPolicyMapOutput struct{ *pulumi.OutputState }

func (EndpointPolicyMapOutput) ElementType added in v6.56.0 

func (EndpointPolicyMapOutput) ElementType() reflect.Type

func (EndpointPolicyMapOutput) MapIndex added in v6.56.0 

func (o EndpointPolicyMapOutput) MapIndex(k pulumi.StringInput) EndpointPolicyOutput

func (EndpointPolicyMapOutput) ToEndpointPolicyMapOutput added in v6.56.0 

func (o EndpointPolicyMapOutput) ToEndpointPolicyMapOutput() EndpointPolicyMapOutput

func (EndpointPolicyMapOutput) ToEndpointPolicyMapOutputWithContext added in v6.56.0 

func (o EndpointPolicyMapOutput) ToEndpointPolicyMapOutputWithContext(ctx context.Context) EndpointPolicyMapOutput

type EndpointPolicyOutput added in v6.56.0 

type EndpointPolicyOutput struct{ *pulumi.OutputState }

func (EndpointPolicyOutput) AuthorizationPolicy added in v6.56.0 

func (o EndpointPolicyOutput) AuthorizationPolicy() pulumi.StringPtrOutput

This field specifies the URL of AuthorizationPolicy resource that applies authorization policies to the inbound traffic at the matched endpoints.

func (EndpointPolicyOutput) ClientTlsPolicy added in v6.56.0 

func (o EndpointPolicyOutput) ClientTlsPolicy() pulumi.StringPtrOutput

A URL referring to a ClientTlsPolicy resource. ClientTlsPolicy can be set to specify the authentication for traffic from the proxy to the actual endpoints.

func (EndpointPolicyOutput) CreateTime added in v6.56.0 

func (o EndpointPolicyOutput) CreateTime() pulumi.StringOutput

Time the TcpRoute was created in UTC.

func (EndpointPolicyOutput) Description added in v6.56.0 

func (o EndpointPolicyOutput) Description() pulumi.StringPtrOutput

A free-text description of the resource. Max length 1024 characters.

func (EndpointPolicyOutput) ElementType added in v6.56.0 

func (EndpointPolicyOutput) ElementType() reflect.Type

func (EndpointPolicyOutput) EndpointMatcher added in v6.56.0 

func (o EndpointPolicyOutput) EndpointMatcher() EndpointPolicyEndpointMatcherOutput

Required. A matcher that selects endpoints to which the policies should be applied. Structure is documented below.

func (EndpointPolicyOutput) Labels added in v6.56.0 

func (o EndpointPolicyOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the TcpRoute resource.

func (EndpointPolicyOutput) Name added in v6.56.0 

func (o EndpointPolicyOutput) Name() pulumi.StringOutput

Name of the EndpointPolicy resource.

func (EndpointPolicyOutput) Project added in v6.56.0 

func (o EndpointPolicyOutput) Project() pulumi.StringOutput

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

func (EndpointPolicyOutput) ServerTlsPolicy added in v6.56.0 

func (o EndpointPolicyOutput) ServerTlsPolicy() pulumi.StringPtrOutput

A URL referring to ServerTlsPolicy resource. ServerTlsPolicy is used to determine the authentication policy to be applied to terminate the inbound traffic at the identified backends.

func (EndpointPolicyOutput) ToEndpointPolicyOutput added in v6.56.0 

func (o EndpointPolicyOutput) ToEndpointPolicyOutput() EndpointPolicyOutput

func (EndpointPolicyOutput) ToEndpointPolicyOutputWithContext added in v6.56.0 

func (o EndpointPolicyOutput) ToEndpointPolicyOutputWithContext(ctx context.Context) EndpointPolicyOutput

func (EndpointPolicyOutput) TrafficPortSelector added in v6.56.0 

func (o EndpointPolicyOutput) TrafficPortSelector() EndpointPolicyTrafficPortSelectorPtrOutput

Port selector for the (matched) endpoints. If no port selector is provided, the matched config is applied to all ports. Structure is documented below.

func (EndpointPolicyOutput) Type added in v6.56.0 

func (o EndpointPolicyOutput) Type() pulumi.StringOutput

The type of endpoint policy. This is primarily used to validate the configuration. Possible values are: `SIDECAR_PROXY`, `GRPC_SERVER`.

func (EndpointPolicyOutput) UpdateTime added in v6.56.0 

func (o EndpointPolicyOutput) UpdateTime() pulumi.StringOutput

Time the TcpRoute was updated in UTC.

type EndpointPolicyState added in v6.56.0 

type EndpointPolicyState struct {
	// This field specifies the URL of AuthorizationPolicy resource that applies authorization policies to the inbound traffic at the matched endpoints.
	AuthorizationPolicy pulumi.StringPtrInput
	// A URL referring to a ClientTlsPolicy resource. ClientTlsPolicy can be set to specify the authentication for traffic from the proxy to the actual endpoints.
	ClientTlsPolicy pulumi.StringPtrInput
	// Time the TcpRoute was created in UTC.
	CreateTime pulumi.StringPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Required. A matcher that selects endpoints to which the policies should be applied.
	// Structure is documented below.
	EndpointMatcher EndpointPolicyEndpointMatcherPtrInput
	// Set of label tags associated with the TcpRoute resource.
	Labels pulumi.StringMapInput
	// Name of the EndpointPolicy resource.
	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
	// A URL referring to ServerTlsPolicy resource. ServerTlsPolicy is used to determine the authentication policy to be applied to terminate the inbound traffic at the identified backends.
	ServerTlsPolicy pulumi.StringPtrInput
	// Port selector for the (matched) endpoints. If no port selector is provided, the matched config is applied to all ports.
	// Structure is documented below.
	TrafficPortSelector EndpointPolicyTrafficPortSelectorPtrInput
	// The type of endpoint policy. This is primarily used to validate the configuration.
	// Possible values are: `SIDECAR_PROXY`, `GRPC_SERVER`.
	Type pulumi.StringPtrInput
	// Time the TcpRoute was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (EndpointPolicyState) ElementType added in v6.56.0 

func (EndpointPolicyState) ElementType() reflect.Type

type EndpointPolicyTrafficPortSelector added in v6.56.0 

type EndpointPolicyTrafficPortSelector struct {
	// List of ports. Can be port numbers or port range (example, [80-90] specifies all ports from 80 to 90, including 80 and 90) or named ports or * to specify all ports. If the list is empty, all ports are selected.
	Ports []string `pulumi:"ports"`
}

type EndpointPolicyTrafficPortSelectorArgs added in v6.56.0 

type EndpointPolicyTrafficPortSelectorArgs struct {
	// List of ports. Can be port numbers or port range (example, [80-90] specifies all ports from 80 to 90, including 80 and 90) or named ports or * to specify all ports. If the list is empty, all ports are selected.
	Ports pulumi.StringArrayInput `pulumi:"ports"`
}

func (EndpointPolicyTrafficPortSelectorArgs) ElementType added in v6.56.0 

func (EndpointPolicyTrafficPortSelectorArgs) ElementType() reflect.Type

func (EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorOutput added in v6.56.0 

func (i EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorOutput() EndpointPolicyTrafficPortSelectorOutput

func (EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorOutputWithContext added in v6.56.0 

func (i EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorOutputWithContext(ctx context.Context) EndpointPolicyTrafficPortSelectorOutput

func (EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorPtrOutput added in v6.56.0 

func (i EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorPtrOutput() EndpointPolicyTrafficPortSelectorPtrOutput

func (EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext added in v6.56.0 

func (i EndpointPolicyTrafficPortSelectorArgs) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext(ctx context.Context) EndpointPolicyTrafficPortSelectorPtrOutput

type EndpointPolicyTrafficPortSelectorInput added in v6.56.0 

type EndpointPolicyTrafficPortSelectorInput interface {
	pulumi.Input

	ToEndpointPolicyTrafficPortSelectorOutput() EndpointPolicyTrafficPortSelectorOutput
	ToEndpointPolicyTrafficPortSelectorOutputWithContext(context.Context) EndpointPolicyTrafficPortSelectorOutput
}

EndpointPolicyTrafficPortSelectorInput is an input type that accepts EndpointPolicyTrafficPortSelectorArgs and EndpointPolicyTrafficPortSelectorOutput values. You can construct a concrete instance of `EndpointPolicyTrafficPortSelectorInput` via: 

EndpointPolicyTrafficPortSelectorArgs{...}

type EndpointPolicyTrafficPortSelectorOutput added in v6.56.0 

type EndpointPolicyTrafficPortSelectorOutput struct{ *pulumi.OutputState }

func (EndpointPolicyTrafficPortSelectorOutput) ElementType added in v6.56.0 

func (EndpointPolicyTrafficPortSelectorOutput) ElementType() reflect.Type

func (EndpointPolicyTrafficPortSelectorOutput) Ports added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorOutput) Ports() pulumi.StringArrayOutput

List of ports. Can be port numbers or port range (example, [80-90] specifies all ports from 80 to 90, including 80 and 90) or named ports or * to specify all ports. If the list is empty, all ports are selected.

func (EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorOutput added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorOutput() EndpointPolicyTrafficPortSelectorOutput

func (EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorOutputWithContext added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorOutputWithContext(ctx context.Context) EndpointPolicyTrafficPortSelectorOutput

func (EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorPtrOutput added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorPtrOutput() EndpointPolicyTrafficPortSelectorPtrOutput

func (EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorOutput) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext(ctx context.Context) EndpointPolicyTrafficPortSelectorPtrOutput

type EndpointPolicyTrafficPortSelectorPtrInput added in v6.56.0 

type EndpointPolicyTrafficPortSelectorPtrInput interface {
	pulumi.Input

	ToEndpointPolicyTrafficPortSelectorPtrOutput() EndpointPolicyTrafficPortSelectorPtrOutput
	ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext(context.Context) EndpointPolicyTrafficPortSelectorPtrOutput
}

EndpointPolicyTrafficPortSelectorPtrInput is an input type that accepts EndpointPolicyTrafficPortSelectorArgs, EndpointPolicyTrafficPortSelectorPtr and EndpointPolicyTrafficPortSelectorPtrOutput values. You can construct a concrete instance of `EndpointPolicyTrafficPortSelectorPtrInput` via: 

        EndpointPolicyTrafficPortSelectorArgs{...}

or:

        nil

func EndpointPolicyTrafficPortSelectorPtr added in v6.56.0 

func EndpointPolicyTrafficPortSelectorPtr(v *EndpointPolicyTrafficPortSelectorArgs) EndpointPolicyTrafficPortSelectorPtrInput

type EndpointPolicyTrafficPortSelectorPtrOutput added in v6.56.0 

type EndpointPolicyTrafficPortSelectorPtrOutput struct{ *pulumi.OutputState }

func (EndpointPolicyTrafficPortSelectorPtrOutput) Elem added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorPtrOutput) Elem() EndpointPolicyTrafficPortSelectorOutput

func (EndpointPolicyTrafficPortSelectorPtrOutput) ElementType added in v6.56.0 

func (EndpointPolicyTrafficPortSelectorPtrOutput) ElementType() reflect.Type

func (EndpointPolicyTrafficPortSelectorPtrOutput) Ports added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorPtrOutput) Ports() pulumi.StringArrayOutput

List of ports. Can be port numbers or port range (example, [80-90] specifies all ports from 80 to 90, including 80 and 90) or named ports or * to specify all ports. If the list is empty, all ports are selected.

func (EndpointPolicyTrafficPortSelectorPtrOutput) ToEndpointPolicyTrafficPortSelectorPtrOutput added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorPtrOutput) ToEndpointPolicyTrafficPortSelectorPtrOutput() EndpointPolicyTrafficPortSelectorPtrOutput

func (EndpointPolicyTrafficPortSelectorPtrOutput) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext added in v6.56.0 

func (o EndpointPolicyTrafficPortSelectorPtrOutput) ToEndpointPolicyTrafficPortSelectorPtrOutputWithContext(ctx context.Context) EndpointPolicyTrafficPortSelectorPtrOutput

type Gateway added in v6.53.0 

type Gateway struct {
	pulumi.CustomResourceState

	// Zero or one IPv4-address on which the Gateway will receive the traffic. When no address is provided,
	// an IP from the subnetwork is allocated This field only applies to gateways of type 'SECURE_WEB_GATEWAY'.
	// Gateways of type 'OPEN_MESH' listen on 0.0.0.0.
	Addresses pulumi.StringArrayOutput `pulumi:"addresses"`
	// A fully-qualified Certificates URL reference. The proxy presents a Certificate (selected based on SNI) when establishing a TLS connection.
	// This feature only applies to gateways of type 'SECURE_WEB_GATEWAY'.
	CertificateUrls pulumi.StringArrayOutput `pulumi:"certificateUrls"`
	// Time the AccessPolicy was created in UTC.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// When deleting a gateway of type 'SECURE_WEB_GATEWAY', this boolean option will also delete auto generated router by the gateway creation.
	// If there is no other gateway of type 'SECURE_WEB_GATEWAY' remaining for that region and network it will be deleted.
	DeleteSwgAutogenRouterOnDestroy pulumi.BoolPtrOutput `pulumi:"deleteSwgAutogenRouterOnDestroy"`
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// A fully-qualified GatewaySecurityPolicy URL reference. Defines how a server should apply security policy to inbound (VM to Proxy) initiated connections.
	// For example: `projects/*/locations/*/gatewaySecurityPolicies/swg-policy`.
	// This policy is specific to gateways of type 'SECURE_WEB_GATEWAY'.
	GatewaySecurityPolicy pulumi.StringPtrOutput `pulumi:"gatewaySecurityPolicy"`
	// Set of label tags associated with the Gateway resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// The location of the gateway.
	// The default value is `global`.
	Location pulumi.StringPtrOutput `pulumi:"location"`
	// Short name of the Gateway resource to be created.
	//
	// ***
	Name pulumi.StringOutput `pulumi:"name"`
	// The relative resource name identifying the VPC network that is using this configuration.
	// For example: `projects/*/global/networks/network-1`.
	// Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY'.
	Network pulumi.StringPtrOutput `pulumi:"network"`
	// One or more port numbers (1-65535), on which the Gateway will receive traffic.
	// The proxy binds to the specified ports. Gateways of type 'SECURE_WEB_GATEWAY' are
	// limited to 1 port. Gateways of type 'OPEN_MESH' listen on 0.0.0.0 and support multiple ports.
	Ports pulumi.IntArrayOutput `pulumi:"ports"`
	// 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"`
	// Immutable. Scope determines how configuration across multiple Gateway instances are merged.
	// The configuration for multiple Gateway instances with the same scope will be merged as presented as
	// a single coniguration to the proxy/load balancer.
	// Max length 64 characters. Scope should start with a letter and can only have letters, numbers, hyphens.
	Scope pulumi.StringPtrOutput `pulumi:"scope"`
	// Server-defined URL of this resource.
	SelfLink pulumi.StringOutput `pulumi:"selfLink"`
	// A fully-qualified ServerTLSPolicy URL reference. Specifies how TLS traffic is terminated.
	// If empty, TLS termination is disabled.
	ServerTlsPolicy pulumi.StringPtrOutput `pulumi:"serverTlsPolicy"`
	// The relative resource name identifying the subnetwork in which this SWG is allocated.
	// For example: `projects/*/regions/us-central1/subnetworks/network-1`.
	// Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY.
	Subnetwork pulumi.StringPtrOutput `pulumi:"subnetwork"`
	// Immutable. The type of the customer-managed gateway. Possible values are: * OPEN_MESH * SECURE_WEB_GATEWAY.
	// Possible values are: `TYPE_UNSPECIFIED`, `OPEN_MESH`, `SECURE_WEB_GATEWAY`.
	Type pulumi.StringOutput `pulumi:"type"`
	// Time the AccessPolicy was updated in UTC.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

Gateway represents the configuration for a proxy, typically a load balancer. It captures the ip:port over which the services are exposed by the proxy, along with any policy configurations. Routes have reference to to Gateways to dictate how requests should be routed by this Gateway.

To get more information about Gateway, see:

* [API documentation](https://cloud.google.com/traffic-director/docs/reference/network-services/rest/v1/projects.locations.gateways)

## Example Usage ### Network Services Gateway 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.NewGateway(ctx, "default", &networkservices.GatewayArgs{
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
			Scope: pulumi.String("default-scope-basic"),
			Type:  pulumi.String("OPEN_MESH"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Gateway 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 {
		_, err := networkservices.NewGateway(ctx, "default", &networkservices.GatewayArgs{
			Description: pulumi.String("my description"),
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
			Scope: pulumi.String("default-scope-advance"),
			Type:  pulumi.String("OPEN_MESH"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Gateway Secure Web Proxy

```go package main

import ( 

"os"

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

) 

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultCertificate, err := certificatemanager.NewCertificate(ctx, "defaultCertificate", &certificatemanager.CertificateArgs{
			Location: pulumi.String("us-central1"),
			SelfManaged: &certificatemanager.CertificateSelfManagedArgs{
				PemCertificate: readFileOrPanic("test-fixtures/certificatemanager/cert.pem"),
				PemPrivateKey:  readFileOrPanic("test-fixtures/certificatemanager/private-key.pem"),
			},
		})
		if err != nil {
			return err
		}
		defaultNetwork, err := compute.NewNetwork(ctx, "defaultNetwork", &compute.NetworkArgs{
			RoutingMode:           pulumi.String("REGIONAL"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		defaultSubnetwork, err := compute.NewSubnetwork(ctx, "defaultSubnetwork", &compute.SubnetworkArgs{
			Purpose:     pulumi.String("PRIVATE"),
			IpCidrRange: pulumi.String("10.128.0.0/20"),
			Region:      pulumi.String("us-central1"),
			Network:     defaultNetwork.ID(),
			Role:        pulumi.String("ACTIVE"),
		})
		if err != nil {
			return err
		}
		proxyonlysubnet, err := compute.NewSubnetwork(ctx, "proxyonlysubnet", &compute.SubnetworkArgs{
			Purpose:     pulumi.String("REGIONAL_MANAGED_PROXY"),
			IpCidrRange: pulumi.String("192.168.0.0/23"),
			Region:      pulumi.String("us-central1"),
			Network:     defaultNetwork.ID(),
			Role:        pulumi.String("ACTIVE"),
		})
		if err != nil {
			return err
		}
		defaultGatewaySecurityPolicy, err := networksecurity.NewGatewaySecurityPolicy(ctx, "defaultGatewaySecurityPolicy", &networksecurity.GatewaySecurityPolicyArgs{
			Location: pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		_, err = networksecurity.NewGatewaySecurityPolicyRule(ctx, "defaultGatewaySecurityPolicyRule", &networksecurity.GatewaySecurityPolicyRuleArgs{
			Location:              pulumi.String("us-central1"),
			GatewaySecurityPolicy: defaultGatewaySecurityPolicy.Name,
			Enabled:               pulumi.Bool(true),
			Priority:              pulumi.Int(1),
			SessionMatcher:        pulumi.String("host() == 'example.com'"),
			BasicProfile:          pulumi.String("ALLOW"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewGateway(ctx, "defaultGateway", &networkservices.GatewayArgs{
			Location: pulumi.String("us-central1"),
			Addresses: pulumi.StringArray{
				pulumi.String("10.128.0.99"),
			},
			Type: pulumi.String("SECURE_WEB_GATEWAY"),
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
			Scope: pulumi.String("my-default-scope1"),
			CertificateUrls: pulumi.StringArray{
				defaultCertificate.ID(),
			},
			GatewaySecurityPolicy:           defaultGatewaySecurityPolicy.ID(),
			Network:                         defaultNetwork.ID(),
			Subnetwork:                      defaultSubnetwork.ID(),
			DeleteSwgAutogenRouterOnDestroy: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			proxyonlysubnet,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Gateway Multiple Swp Same Network

```go package main

import ( 

"os"

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

) 

func readFileOrPanic(path string) pulumi.StringPtrInput {
	data, err := os.ReadFile(path)
	if err != nil {
		panic(err.Error())
	}
	return pulumi.String(string(data))
}

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultCertificate, err := certificatemanager.NewCertificate(ctx, "defaultCertificate", &certificatemanager.CertificateArgs{
			Location: pulumi.String("us-south1"),
			SelfManaged: &certificatemanager.CertificateSelfManagedArgs{
				PemCertificate: readFileOrPanic("test-fixtures/certificatemanager/cert.pem"),
				PemPrivateKey:  readFileOrPanic("test-fixtures/certificatemanager/private-key.pem"),
			},
		})
		if err != nil {
			return err
		}
		defaultNetwork, err := compute.NewNetwork(ctx, "defaultNetwork", &compute.NetworkArgs{
			RoutingMode:           pulumi.String("REGIONAL"),
			AutoCreateSubnetworks: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		defaultSubnetwork, err := compute.NewSubnetwork(ctx, "defaultSubnetwork", &compute.SubnetworkArgs{
			Purpose:     pulumi.String("PRIVATE"),
			IpCidrRange: pulumi.String("10.128.0.0/20"),
			Region:      pulumi.String("us-south1"),
			Network:     defaultNetwork.ID(),
			Role:        pulumi.String("ACTIVE"),
		})
		if err != nil {
			return err
		}
		proxyonlysubnet, err := compute.NewSubnetwork(ctx, "proxyonlysubnet", &compute.SubnetworkArgs{
			Purpose:     pulumi.String("REGIONAL_MANAGED_PROXY"),
			IpCidrRange: pulumi.String("192.168.0.0/23"),
			Region:      pulumi.String("us-south1"),
			Network:     defaultNetwork.ID(),
			Role:        pulumi.String("ACTIVE"),
		})
		if err != nil {
			return err
		}
		defaultGatewaySecurityPolicy, err := networksecurity.NewGatewaySecurityPolicy(ctx, "defaultGatewaySecurityPolicy", &networksecurity.GatewaySecurityPolicyArgs{
			Location: pulumi.String("us-south1"),
		})
		if err != nil {
			return err
		}
		_, err = networksecurity.NewGatewaySecurityPolicyRule(ctx, "defaultGatewaySecurityPolicyRule", &networksecurity.GatewaySecurityPolicyRuleArgs{
			Location:              pulumi.String("us-south1"),
			GatewaySecurityPolicy: defaultGatewaySecurityPolicy.Name,
			Enabled:               pulumi.Bool(true),
			Priority:              pulumi.Int(1),
			SessionMatcher:        pulumi.String("host() == 'example.com'"),
			BasicProfile:          pulumi.String("ALLOW"),
		})
		if err != nil {
			return err
		}
		_, err = networkservices.NewGateway(ctx, "defaultGateway", &networkservices.GatewayArgs{
			Location: pulumi.String("us-south1"),
			Addresses: pulumi.StringArray{
				pulumi.String("10.128.0.99"),
			},
			Type: pulumi.String("SECURE_WEB_GATEWAY"),
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
			Scope: pulumi.String("my-default-scope1"),
			CertificateUrls: pulumi.StringArray{
				defaultCertificate.ID(),
			},
			GatewaySecurityPolicy:           defaultGatewaySecurityPolicy.ID(),
			Network:                         defaultNetwork.ID(),
			Subnetwork:                      defaultSubnetwork.ID(),
			DeleteSwgAutogenRouterOnDestroy: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			proxyonlysubnet,
		}))
		if err != nil {
			return err
		}
		_, err = networkservices.NewGateway(ctx, "gateway2", &networkservices.GatewayArgs{
			Location: pulumi.String("us-south1"),
			Addresses: pulumi.StringArray{
				pulumi.String("10.128.0.98"),
			},
			Type: pulumi.String("SECURE_WEB_GATEWAY"),
			Ports: pulumi.IntArray{
				pulumi.Int(443),
			},
			Scope: pulumi.String("my-default-scope2"),
			CertificateUrls: pulumi.StringArray{
				defaultCertificate.ID(),
			},
			GatewaySecurityPolicy:           defaultGatewaySecurityPolicy.ID(),
			Network:                         defaultNetwork.ID(),
			Subnetwork:                      defaultSubnetwork.ID(),
			DeleteSwgAutogenRouterOnDestroy: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			proxyonlysubnet,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Gateway can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/gateway:Gateway default projects/{{project}}/locations/{{location}}/gateways/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/gateway:Gateway default {{project}}/{{location}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/gateway:Gateway default {{location}}/{{name}}

```

func GetGateway added in v6.53.0 

func GetGateway(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GatewayState, opts ...pulumi.ResourceOption) (*Gateway, error)

GetGateway gets an existing Gateway 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 NewGateway added in v6.53.0 

func NewGateway(ctx *pulumi.Context,
	name string, args *GatewayArgs, opts ...pulumi.ResourceOption) (*Gateway, error)

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

func (*Gateway) ElementType added in v6.53.0 

func (*Gateway) ElementType() reflect.Type

func (*Gateway) ToGatewayOutput added in v6.53.0 

func (i *Gateway) ToGatewayOutput() GatewayOutput

func (*Gateway) ToGatewayOutputWithContext added in v6.53.0 

func (i *Gateway) ToGatewayOutputWithContext(ctx context.Context) GatewayOutput

type GatewayArgs added in v6.53.0 

type GatewayArgs struct {
	// Zero or one IPv4-address on which the Gateway will receive the traffic. When no address is provided,
	// an IP from the subnetwork is allocated This field only applies to gateways of type 'SECURE_WEB_GATEWAY'.
	// Gateways of type 'OPEN_MESH' listen on 0.0.0.0.
	Addresses pulumi.StringArrayInput
	// A fully-qualified Certificates URL reference. The proxy presents a Certificate (selected based on SNI) when establishing a TLS connection.
	// This feature only applies to gateways of type 'SECURE_WEB_GATEWAY'.
	CertificateUrls pulumi.StringArrayInput
	// When deleting a gateway of type 'SECURE_WEB_GATEWAY', this boolean option will also delete auto generated router by the gateway creation.
	// If there is no other gateway of type 'SECURE_WEB_GATEWAY' remaining for that region and network it will be deleted.
	DeleteSwgAutogenRouterOnDestroy pulumi.BoolPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// A fully-qualified GatewaySecurityPolicy URL reference. Defines how a server should apply security policy to inbound (VM to Proxy) initiated connections.
	// For example: `projects/*/locations/*/gatewaySecurityPolicies/swg-policy`.
	// This policy is specific to gateways of type 'SECURE_WEB_GATEWAY'.
	GatewaySecurityPolicy pulumi.StringPtrInput
	// Set of label tags associated with the Gateway resource.
	Labels pulumi.StringMapInput
	// The location of the gateway.
	// The default value is `global`.
	Location pulumi.StringPtrInput
	// Short name of the Gateway resource to be created.
	//
	// ***
	Name pulumi.StringPtrInput
	// The relative resource name identifying the VPC network that is using this configuration.
	// For example: `projects/*/global/networks/network-1`.
	// Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY'.
	Network pulumi.StringPtrInput
	// One or more port numbers (1-65535), on which the Gateway will receive traffic.
	// The proxy binds to the specified ports. Gateways of type 'SECURE_WEB_GATEWAY' are
	// limited to 1 port. Gateways of type 'OPEN_MESH' listen on 0.0.0.0 and support multiple ports.
	Ports pulumi.IntArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Immutable. Scope determines how configuration across multiple Gateway instances are merged.
	// The configuration for multiple Gateway instances with the same scope will be merged as presented as
	// a single coniguration to the proxy/load balancer.
	// Max length 64 characters. Scope should start with a letter and can only have letters, numbers, hyphens.
	Scope pulumi.StringPtrInput
	// A fully-qualified ServerTLSPolicy URL reference. Specifies how TLS traffic is terminated.
	// If empty, TLS termination is disabled.
	ServerTlsPolicy pulumi.StringPtrInput
	// The relative resource name identifying the subnetwork in which this SWG is allocated.
	// For example: `projects/*/regions/us-central1/subnetworks/network-1`.
	// Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY.
	Subnetwork pulumi.StringPtrInput
	// Immutable. The type of the customer-managed gateway. Possible values are: * OPEN_MESH * SECURE_WEB_GATEWAY.
	// Possible values are: `TYPE_UNSPECIFIED`, `OPEN_MESH`, `SECURE_WEB_GATEWAY`.
	Type pulumi.StringInput
}

The set of arguments for constructing a Gateway resource.

func (GatewayArgs) ElementType added in v6.53.0 

func (GatewayArgs) ElementType() reflect.Type

type GatewayArray added in v6.53.0 

type GatewayArray []GatewayInput

func (GatewayArray) ElementType added in v6.53.0 

func (GatewayArray) ElementType() reflect.Type

func (GatewayArray) ToGatewayArrayOutput added in v6.53.0 

func (i GatewayArray) ToGatewayArrayOutput() GatewayArrayOutput

func (GatewayArray) ToGatewayArrayOutputWithContext added in v6.53.0 

func (i GatewayArray) ToGatewayArrayOutputWithContext(ctx context.Context) GatewayArrayOutput

type GatewayArrayInput added in v6.53.0 

type GatewayArrayInput interface {
	pulumi.Input

	ToGatewayArrayOutput() GatewayArrayOutput
	ToGatewayArrayOutputWithContext(context.Context) GatewayArrayOutput
}

GatewayArrayInput is an input type that accepts GatewayArray and GatewayArrayOutput values. You can construct a concrete instance of `GatewayArrayInput` via: 

GatewayArray{ GatewayArgs{...} }

type GatewayArrayOutput added in v6.53.0 

type GatewayArrayOutput struct{ *pulumi.OutputState }

func (GatewayArrayOutput) ElementType added in v6.53.0 

func (GatewayArrayOutput) ElementType() reflect.Type

func (GatewayArrayOutput) Index added in v6.53.0 

func (o GatewayArrayOutput) Index(i pulumi.IntInput) GatewayOutput

func (GatewayArrayOutput) ToGatewayArrayOutput added in v6.53.0 

func (o GatewayArrayOutput) ToGatewayArrayOutput() GatewayArrayOutput

func (GatewayArrayOutput) ToGatewayArrayOutputWithContext added in v6.53.0 

func (o GatewayArrayOutput) ToGatewayArrayOutputWithContext(ctx context.Context) GatewayArrayOutput

type GatewayInput added in v6.53.0 

type GatewayInput interface {
	pulumi.Input

	ToGatewayOutput() GatewayOutput
	ToGatewayOutputWithContext(ctx context.Context) GatewayOutput
}

type GatewayMap added in v6.53.0 

type GatewayMap map[string]GatewayInput

func (GatewayMap) ElementType added in v6.53.0 

func (GatewayMap) ElementType() reflect.Type

func (GatewayMap) ToGatewayMapOutput added in v6.53.0 

func (i GatewayMap) ToGatewayMapOutput() GatewayMapOutput

func (GatewayMap) ToGatewayMapOutputWithContext added in v6.53.0 

func (i GatewayMap) ToGatewayMapOutputWithContext(ctx context.Context) GatewayMapOutput

type GatewayMapInput added in v6.53.0 

type GatewayMapInput interface {
	pulumi.Input

	ToGatewayMapOutput() GatewayMapOutput
	ToGatewayMapOutputWithContext(context.Context) GatewayMapOutput
}

GatewayMapInput is an input type that accepts GatewayMap and GatewayMapOutput values. You can construct a concrete instance of `GatewayMapInput` via: 

GatewayMap{ "key": GatewayArgs{...} }

type GatewayMapOutput added in v6.53.0 

type GatewayMapOutput struct{ *pulumi.OutputState }

func (GatewayMapOutput) ElementType added in v6.53.0 

func (GatewayMapOutput) ElementType() reflect.Type

func (GatewayMapOutput) MapIndex added in v6.53.0 

func (o GatewayMapOutput) MapIndex(k pulumi.StringInput) GatewayOutput

func (GatewayMapOutput) ToGatewayMapOutput added in v6.53.0 

func (o GatewayMapOutput) ToGatewayMapOutput() GatewayMapOutput

func (GatewayMapOutput) ToGatewayMapOutputWithContext added in v6.53.0 

func (o GatewayMapOutput) ToGatewayMapOutputWithContext(ctx context.Context) GatewayMapOutput

type GatewayOutput added in v6.53.0 

type GatewayOutput struct{ *pulumi.OutputState }

func (GatewayOutput) Addresses added in v6.59.0 

func (o GatewayOutput) Addresses() pulumi.StringArrayOutput

Zero or one IPv4-address on which the Gateway will receive the traffic. When no address is provided, an IP from the subnetwork is allocated This field only applies to gateways of type 'SECURE_WEB_GATEWAY'. Gateways of type 'OPEN_MESH' listen on 0.0.0.0.

func (GatewayOutput) CertificateUrls added in v6.59.0 

func (o GatewayOutput) CertificateUrls() pulumi.StringArrayOutput

A fully-qualified Certificates URL reference. The proxy presents a Certificate (selected based on SNI) when establishing a TLS connection. This feature only applies to gateways of type 'SECURE_WEB_GATEWAY'.

func (GatewayOutput) CreateTime added in v6.53.0 

func (o GatewayOutput) CreateTime() pulumi.StringOutput

Time the AccessPolicy was created in UTC.

func (GatewayOutput) DeleteSwgAutogenRouterOnDestroy added in v6.59.0 

func (o GatewayOutput) DeleteSwgAutogenRouterOnDestroy() pulumi.BoolPtrOutput

When deleting a gateway of type 'SECURE_WEB_GATEWAY', this boolean option will also delete auto generated router by the gateway creation. If there is no other gateway of type 'SECURE_WEB_GATEWAY' remaining for that region and network it will be deleted.

func (GatewayOutput) Description added in v6.53.0 

func (o GatewayOutput) Description() pulumi.StringPtrOutput

A free-text description of the resource. Max length 1024 characters.

func (GatewayOutput) ElementType added in v6.53.0 

func (GatewayOutput) ElementType() reflect.Type

func (GatewayOutput) GatewaySecurityPolicy added in v6.59.0 

func (o GatewayOutput) GatewaySecurityPolicy() pulumi.StringPtrOutput

A fully-qualified GatewaySecurityPolicy URL reference. Defines how a server should apply security policy to inbound (VM to Proxy) initiated connections. For example: `projects/*/locations/*/gatewaySecurityPolicies/swg-policy`. This policy is specific to gateways of type 'SECURE_WEB_GATEWAY'.

func (GatewayOutput) Labels added in v6.53.0 

func (o GatewayOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the Gateway resource.

func (GatewayOutput) Location added in v6.53.0 

func (o GatewayOutput) Location() pulumi.StringPtrOutput

The location of the gateway. The default value is `global`.

func (GatewayOutput) Name added in v6.53.0 

func (o GatewayOutput) Name() pulumi.StringOutput

Short name of the Gateway resource to be created.

***

func (GatewayOutput) Network added in v6.59.0 

func (o GatewayOutput) Network() pulumi.StringPtrOutput

The relative resource name identifying the VPC network that is using this configuration. For example: `projects/*/global/networks/network-1`. Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY'.

func (GatewayOutput) Ports added in v6.53.0 

func (o GatewayOutput) Ports() pulumi.IntArrayOutput

One or more port numbers (1-65535), on which the Gateway will receive traffic. The proxy binds to the specified ports. Gateways of type 'SECURE_WEB_GATEWAY' are limited to 1 port. Gateways of type 'OPEN_MESH' listen on 0.0.0.0 and support multiple ports.

func (GatewayOutput) Project added in v6.53.0 

func (o GatewayOutput) Project() pulumi.StringOutput

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

func (GatewayOutput) Scope added in v6.53.0 

func (o GatewayOutput) Scope() pulumi.StringPtrOutput

Immutable. Scope determines how configuration across multiple Gateway instances are merged. The configuration for multiple Gateway instances with the same scope will be merged as presented as a single coniguration to the proxy/load balancer. Max length 64 characters. Scope should start with a letter and can only have letters, numbers, hyphens. 

func (o GatewayOutput) SelfLink() pulumi.StringOutput

Server-defined URL of this resource.

func (GatewayOutput) ServerTlsPolicy added in v6.53.0 

func (o GatewayOutput) ServerTlsPolicy() pulumi.StringPtrOutput

A fully-qualified ServerTLSPolicy URL reference. Specifies how TLS traffic is terminated. If empty, TLS termination is disabled.

func (GatewayOutput) Subnetwork added in v6.59.0 

func (o GatewayOutput) Subnetwork() pulumi.StringPtrOutput

The relative resource name identifying the subnetwork in which this SWG is allocated. For example: `projects/*/regions/us-central1/subnetworks/network-1`. Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY.

func (GatewayOutput) ToGatewayOutput added in v6.53.0 

func (o GatewayOutput) ToGatewayOutput() GatewayOutput

func (GatewayOutput) ToGatewayOutputWithContext added in v6.53.0 

func (o GatewayOutput) ToGatewayOutputWithContext(ctx context.Context) GatewayOutput

func (GatewayOutput) Type added in v6.53.0 

func (o GatewayOutput) Type() pulumi.StringOutput

Immutable. The type of the customer-managed gateway. Possible values are: * OPEN_MESH * SECURE_WEB_GATEWAY. Possible values are: `TYPE_UNSPECIFIED`, `OPEN_MESH`, `SECURE_WEB_GATEWAY`.

func (GatewayOutput) UpdateTime added in v6.53.0 

func (o GatewayOutput) UpdateTime() pulumi.StringOutput

Time the AccessPolicy was updated in UTC.

type GatewayState added in v6.53.0 

type GatewayState struct {
	// Zero or one IPv4-address on which the Gateway will receive the traffic. When no address is provided,
	// an IP from the subnetwork is allocated This field only applies to gateways of type 'SECURE_WEB_GATEWAY'.
	// Gateways of type 'OPEN_MESH' listen on 0.0.0.0.
	Addresses pulumi.StringArrayInput
	// A fully-qualified Certificates URL reference. The proxy presents a Certificate (selected based on SNI) when establishing a TLS connection.
	// This feature only applies to gateways of type 'SECURE_WEB_GATEWAY'.
	CertificateUrls pulumi.StringArrayInput
	// Time the AccessPolicy was created in UTC.
	CreateTime pulumi.StringPtrInput
	// When deleting a gateway of type 'SECURE_WEB_GATEWAY', this boolean option will also delete auto generated router by the gateway creation.
	// If there is no other gateway of type 'SECURE_WEB_GATEWAY' remaining for that region and network it will be deleted.
	DeleteSwgAutogenRouterOnDestroy pulumi.BoolPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// A fully-qualified GatewaySecurityPolicy URL reference. Defines how a server should apply security policy to inbound (VM to Proxy) initiated connections.
	// For example: `projects/*/locations/*/gatewaySecurityPolicies/swg-policy`.
	// This policy is specific to gateways of type 'SECURE_WEB_GATEWAY'.
	GatewaySecurityPolicy pulumi.StringPtrInput
	// Set of label tags associated with the Gateway resource.
	Labels pulumi.StringMapInput
	// The location of the gateway.
	// The default value is `global`.
	Location pulumi.StringPtrInput
	// Short name of the Gateway resource to be created.
	//
	// ***
	Name pulumi.StringPtrInput
	// The relative resource name identifying the VPC network that is using this configuration.
	// For example: `projects/*/global/networks/network-1`.
	// Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY'.
	Network pulumi.StringPtrInput
	// One or more port numbers (1-65535), on which the Gateway will receive traffic.
	// The proxy binds to the specified ports. Gateways of type 'SECURE_WEB_GATEWAY' are
	// limited to 1 port. Gateways of type 'OPEN_MESH' listen on 0.0.0.0 and support multiple ports.
	Ports pulumi.IntArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Immutable. Scope determines how configuration across multiple Gateway instances are merged.
	// The configuration for multiple Gateway instances with the same scope will be merged as presented as
	// a single coniguration to the proxy/load balancer.
	// Max length 64 characters. Scope should start with a letter and can only have letters, numbers, hyphens.
	Scope pulumi.StringPtrInput
	// Server-defined URL of this resource.
	SelfLink pulumi.StringPtrInput
	// A fully-qualified ServerTLSPolicy URL reference. Specifies how TLS traffic is terminated.
	// If empty, TLS termination is disabled.
	ServerTlsPolicy pulumi.StringPtrInput
	// The relative resource name identifying the subnetwork in which this SWG is allocated.
	// For example: `projects/*/regions/us-central1/subnetworks/network-1`.
	// Currently, this field is specific to gateways of type 'SECURE_WEB_GATEWAY.
	Subnetwork pulumi.StringPtrInput
	// Immutable. The type of the customer-managed gateway. Possible values are: * OPEN_MESH * SECURE_WEB_GATEWAY.
	// Possible values are: `TYPE_UNSPECIFIED`, `OPEN_MESH`, `SECURE_WEB_GATEWAY`.
	Type pulumi.StringPtrInput
	// Time the AccessPolicy was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (GatewayState) ElementType added in v6.53.0 

func (GatewayState) ElementType() reflect.Type

type GrpcRoute added in v6.56.0 

type GrpcRoute struct {
	pulumi.CustomResourceState

	// Time the GrpcRoute was created in UTC.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// List of gateways this GrpcRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	Gateways pulumi.StringArrayOutput `pulumi:"gateways"`
	// Required. Service hostnames with an optional port for which this route describes traffic.
	Hostnames pulumi.StringArrayOutput `pulumi:"hostnames"`
	// Set of label tags associated with the GrpcRoute resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// List of meshes this GrpcRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	Meshes pulumi.StringArrayOutput `pulumi:"meshes"`
	// Name of the GrpcRoute resource.
	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"`
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules GrpcRouteRuleArrayOutput `pulumi:"rules"`
	// Server-defined URL of this resource.
	SelfLink pulumi.StringOutput `pulumi:"selfLink"`
	// Time the GrpcRoute was updated in UTC.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

## Example Usage ### Network Services Grpc Route 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.NewGrpcRoute(ctx, "default", &networkservices.GrpcRouteArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.GrpcRouteRuleArray{
				&networkservices.GrpcRouteRuleArgs{
					Matches: networkservices.GrpcRouteRuleMatchArray{
						&networkservices.GrpcRouteRuleMatchArgs{
							Headers: networkservices.GrpcRouteRuleMatchHeaderArray{
								&networkservices.GrpcRouteRuleMatchHeaderArgs{
									Key:   pulumi.String("key"),
									Value: pulumi.String("value"),
								},
							},
						},
					},
					Action: &networkservices.GrpcRouteRuleActionArgs{
						RetryPolicy: &networkservices.GrpcRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("cancelled"),
							},
							NumRetries: pulumi.Int(1),
						},
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Grpc Route Matches And Actions

```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.NewGrpcRoute(ctx, "default", &networkservices.GrpcRouteArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.GrpcRouteRuleArray{
				&networkservices.GrpcRouteRuleArgs{
					Matches: networkservices.GrpcRouteRuleMatchArray{
						&networkservices.GrpcRouteRuleMatchArgs{
							Headers: networkservices.GrpcRouteRuleMatchHeaderArray{
								&networkservices.GrpcRouteRuleMatchHeaderArgs{
									Key:   pulumi.String("key"),
									Value: pulumi.String("value"),
								},
							},
						},
						&networkservices.GrpcRouteRuleMatchArgs{
							Headers: networkservices.GrpcRouteRuleMatchHeaderArray{
								&networkservices.GrpcRouteRuleMatchHeaderArgs{
									Key:   pulumi.String("key"),
									Value: pulumi.String("value"),
								},
							},
							Method: &networkservices.GrpcRouteRuleMatchMethodArgs{
								GrpcService:   pulumi.String("foo"),
								GrpcMethod:    pulumi.String("bar"),
								CaseSensitive: pulumi.Bool(true),
							},
						},
					},
					Action: &networkservices.GrpcRouteRuleActionArgs{
						FaultInjectionPolicy: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyArgs{
							Delay: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyDelayArgs{
								FixedDelay: pulumi.String("1s"),
								Percentage: pulumi.Int(1),
							},
							Abort: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyAbortArgs{
								HttpStatus: pulumi.Int(500),
								Percentage: pulumi.Int(1),
							},
						},
						RetryPolicy: &networkservices.GrpcRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("cancelled"),
							},
							NumRetries: pulumi.Int(1),
						},
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Grpc Route Actions

```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.NewGrpcRoute(ctx, "default", &networkservices.GrpcRouteArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.GrpcRouteRuleArray{
				&networkservices.GrpcRouteRuleArgs{
					Action: &networkservices.GrpcRouteRuleActionArgs{
						FaultInjectionPolicy: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyArgs{
							Delay: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyDelayArgs{
								FixedDelay: pulumi.String("1s"),
								Percentage: pulumi.Int(1),
							},
							Abort: &networkservices.GrpcRouteRuleActionFaultInjectionPolicyAbortArgs{
								HttpStatus: pulumi.Int(500),
								Percentage: pulumi.Int(1),
							},
						},
						RetryPolicy: &networkservices.GrpcRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("cancelled"),
							},
							NumRetries: pulumi.Int(1),
						},
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

GrpcRoute can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/grpcRoute:GrpcRoute default projects/{{project}}/locations/global/grpcRoutes/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/grpcRoute:GrpcRoute default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/grpcRoute:GrpcRoute default {{name}}

```

func GetGrpcRoute added in v6.56.0 

func GetGrpcRoute(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GrpcRouteState, opts ...pulumi.ResourceOption) (*GrpcRoute, error)

GetGrpcRoute gets an existing GrpcRoute 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 NewGrpcRoute added in v6.56.0 

func NewGrpcRoute(ctx *pulumi.Context,
	name string, args *GrpcRouteArgs, opts ...pulumi.ResourceOption) (*GrpcRoute, error)

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

func (*GrpcRoute) ElementType added in v6.56.0 

func (*GrpcRoute) ElementType() reflect.Type

func (*GrpcRoute) ToGrpcRouteOutput added in v6.56.0 

func (i *GrpcRoute) ToGrpcRouteOutput() GrpcRouteOutput

func (*GrpcRoute) ToGrpcRouteOutputWithContext added in v6.56.0 

func (i *GrpcRoute) ToGrpcRouteOutputWithContext(ctx context.Context) GrpcRouteOutput

type GrpcRouteArgs added in v6.56.0 

type GrpcRouteArgs struct {
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// List of gateways this GrpcRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	Gateways pulumi.StringArrayInput
	// Required. Service hostnames with an optional port for which this route describes traffic.
	Hostnames pulumi.StringArrayInput
	// Set of label tags associated with the GrpcRoute resource.
	Labels pulumi.StringMapInput
	// List of meshes this GrpcRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	Meshes pulumi.StringArrayInput
	// Name of the GrpcRoute resource.
	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
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules GrpcRouteRuleArrayInput
}

The set of arguments for constructing a GrpcRoute resource.

func (GrpcRouteArgs) ElementType added in v6.56.0 

func (GrpcRouteArgs) ElementType() reflect.Type

type GrpcRouteArray added in v6.56.0 

type GrpcRouteArray []GrpcRouteInput

func (GrpcRouteArray) ElementType added in v6.56.0 

func (GrpcRouteArray) ElementType() reflect.Type

func (GrpcRouteArray) ToGrpcRouteArrayOutput added in v6.56.0 

func (i GrpcRouteArray) ToGrpcRouteArrayOutput() GrpcRouteArrayOutput

func (GrpcRouteArray) ToGrpcRouteArrayOutputWithContext added in v6.56.0 

func (i GrpcRouteArray) ToGrpcRouteArrayOutputWithContext(ctx context.Context) GrpcRouteArrayOutput

type GrpcRouteArrayInput added in v6.56.0 

type GrpcRouteArrayInput interface {
	pulumi.Input

	ToGrpcRouteArrayOutput() GrpcRouteArrayOutput
	ToGrpcRouteArrayOutputWithContext(context.Context) GrpcRouteArrayOutput
}

GrpcRouteArrayInput is an input type that accepts GrpcRouteArray and GrpcRouteArrayOutput values. You can construct a concrete instance of `GrpcRouteArrayInput` via: 

GrpcRouteArray{ GrpcRouteArgs{...} }

type GrpcRouteArrayOutput added in v6.56.0 

type GrpcRouteArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteArrayOutput) ElementType added in v6.56.0 

func (GrpcRouteArrayOutput) ElementType() reflect.Type

func (GrpcRouteArrayOutput) Index added in v6.56.0 

func (o GrpcRouteArrayOutput) Index(i pulumi.IntInput) GrpcRouteOutput

func (GrpcRouteArrayOutput) ToGrpcRouteArrayOutput added in v6.56.0 

func (o GrpcRouteArrayOutput) ToGrpcRouteArrayOutput() GrpcRouteArrayOutput

func (GrpcRouteArrayOutput) ToGrpcRouteArrayOutputWithContext added in v6.56.0 

func (o GrpcRouteArrayOutput) ToGrpcRouteArrayOutputWithContext(ctx context.Context) GrpcRouteArrayOutput

type GrpcRouteInput added in v6.56.0 

type GrpcRouteInput interface {
	pulumi.Input

	ToGrpcRouteOutput() GrpcRouteOutput
	ToGrpcRouteOutputWithContext(ctx context.Context) GrpcRouteOutput
}

type GrpcRouteMap added in v6.56.0 

type GrpcRouteMap map[string]GrpcRouteInput

func (GrpcRouteMap) ElementType added in v6.56.0 

func (GrpcRouteMap) ElementType() reflect.Type

func (GrpcRouteMap) ToGrpcRouteMapOutput added in v6.56.0 

func (i GrpcRouteMap) ToGrpcRouteMapOutput() GrpcRouteMapOutput

func (GrpcRouteMap) ToGrpcRouteMapOutputWithContext added in v6.56.0 

func (i GrpcRouteMap) ToGrpcRouteMapOutputWithContext(ctx context.Context) GrpcRouteMapOutput

type GrpcRouteMapInput added in v6.56.0 

type GrpcRouteMapInput interface {
	pulumi.Input

	ToGrpcRouteMapOutput() GrpcRouteMapOutput
	ToGrpcRouteMapOutputWithContext(context.Context) GrpcRouteMapOutput
}

GrpcRouteMapInput is an input type that accepts GrpcRouteMap and GrpcRouteMapOutput values. You can construct a concrete instance of `GrpcRouteMapInput` via: 

GrpcRouteMap{ "key": GrpcRouteArgs{...} }

type GrpcRouteMapOutput added in v6.56.0 

type GrpcRouteMapOutput struct{ *pulumi.OutputState }

func (GrpcRouteMapOutput) ElementType added in v6.56.0 

func (GrpcRouteMapOutput) ElementType() reflect.Type

func (GrpcRouteMapOutput) MapIndex added in v6.56.0 

func (o GrpcRouteMapOutput) MapIndex(k pulumi.StringInput) GrpcRouteOutput

func (GrpcRouteMapOutput) ToGrpcRouteMapOutput added in v6.56.0 

func (o GrpcRouteMapOutput) ToGrpcRouteMapOutput() GrpcRouteMapOutput

func (GrpcRouteMapOutput) ToGrpcRouteMapOutputWithContext added in v6.56.0 

func (o GrpcRouteMapOutput) ToGrpcRouteMapOutputWithContext(ctx context.Context) GrpcRouteMapOutput

type GrpcRouteOutput added in v6.56.0 

type GrpcRouteOutput struct{ *pulumi.OutputState }

func (GrpcRouteOutput) CreateTime added in v6.56.0 

func (o GrpcRouteOutput) CreateTime() pulumi.StringOutput

Time the GrpcRoute was created in UTC.

func (GrpcRouteOutput) Description added in v6.56.0 

func (o GrpcRouteOutput) Description() pulumi.StringPtrOutput

A free-text description of the resource. Max length 1024 characters.

func (GrpcRouteOutput) ElementType added in v6.56.0 

func (GrpcRouteOutput) ElementType() reflect.Type

func (GrpcRouteOutput) Gateways added in v6.56.0 

func (o GrpcRouteOutput) Gateways() pulumi.StringArrayOutput

List of gateways this GrpcRoute is attached to, as one of the routing rules to route the requests served by the gateway.

func (GrpcRouteOutput) Hostnames added in v6.56.0 

func (o GrpcRouteOutput) Hostnames() pulumi.StringArrayOutput

Required. Service hostnames with an optional port for which this route describes traffic.

func (GrpcRouteOutput) Labels added in v6.56.0 

func (o GrpcRouteOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the GrpcRoute resource.

func (GrpcRouteOutput) Meshes added in v6.56.0 

func (o GrpcRouteOutput) Meshes() pulumi.StringArrayOutput

List of meshes this GrpcRoute is attached to, as one of the routing rules to route the requests served by the mesh.

func (GrpcRouteOutput) Name added in v6.56.0 

func (o GrpcRouteOutput) Name() pulumi.StringOutput

Name of the GrpcRoute resource.

func (GrpcRouteOutput) Project added in v6.56.0 

func (o GrpcRouteOutput) Project() pulumi.StringOutput

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

func (GrpcRouteOutput) Rules added in v6.56.0 

func (o GrpcRouteOutput) Rules() GrpcRouteRuleArrayOutput

Rules that define how traffic is routed and handled. Structure is documented below. 

func (o GrpcRouteOutput) SelfLink() pulumi.StringOutput

Server-defined URL of this resource.

func (GrpcRouteOutput) ToGrpcRouteOutput added in v6.56.0 

func (o GrpcRouteOutput) ToGrpcRouteOutput() GrpcRouteOutput

func (GrpcRouteOutput) ToGrpcRouteOutputWithContext added in v6.56.0 

func (o GrpcRouteOutput) ToGrpcRouteOutputWithContext(ctx context.Context) GrpcRouteOutput

func (GrpcRouteOutput) UpdateTime added in v6.56.0 

func (o GrpcRouteOutput) UpdateTime() pulumi.StringOutput

Time the GrpcRoute was updated in UTC.

type GrpcRouteRule added in v6.56.0 

type GrpcRouteRule struct {
	// Required. A detailed rule defining how to route traffic.
	// Structure is documented below.
	Action *GrpcRouteRuleAction `pulumi:"action"`
	// Matches define conditions used for matching the rule against incoming gRPC requests.
	// Structure is documented below.
	Matches []GrpcRouteRuleMatch `pulumi:"matches"`
}

type GrpcRouteRuleAction added in v6.56.0 

type GrpcRouteRuleAction struct {
	// The destination to which traffic should be forwarded.
	// Structure is documented below.
	Destinations []GrpcRouteRuleActionDestination `pulumi:"destinations"`
	// The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
	// Structure is documented below.
	FaultInjectionPolicy *GrpcRouteRuleActionFaultInjectionPolicy `pulumi:"faultInjectionPolicy"`
	// Specifies the retry policy associated with this route.
	// Structure is documented below.
	RetryPolicy *GrpcRouteRuleActionRetryPolicy `pulumi:"retryPolicy"`
	// Specifies the timeout for selected route.
	Timeout *string `pulumi:"timeout"`
}

type GrpcRouteRuleActionArgs added in v6.56.0 

type GrpcRouteRuleActionArgs struct {
	// The destination to which traffic should be forwarded.
	// Structure is documented below.
	Destinations GrpcRouteRuleActionDestinationArrayInput `pulumi:"destinations"`
	// The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
	// Structure is documented below.
	FaultInjectionPolicy GrpcRouteRuleActionFaultInjectionPolicyPtrInput `pulumi:"faultInjectionPolicy"`
	// Specifies the retry policy associated with this route.
	// Structure is documented below.
	RetryPolicy GrpcRouteRuleActionRetryPolicyPtrInput `pulumi:"retryPolicy"`
	// Specifies the timeout for selected route.
	Timeout pulumi.StringPtrInput `pulumi:"timeout"`
}

func (GrpcRouteRuleActionArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleActionArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionOutput added in v6.56.0 

func (i GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionOutput() GrpcRouteRuleActionOutput

func (GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionOutputWithContext(ctx context.Context) GrpcRouteRuleActionOutput

func (GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionPtrOutput added in v6.56.0 

func (i GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionPtrOutput() GrpcRouteRuleActionPtrOutput

func (GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionPtrOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionArgs) ToGrpcRouteRuleActionPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionPtrOutput

type GrpcRouteRuleActionDestination added in v6.56.0 

type GrpcRouteRuleActionDestination struct {
	// The URL of a BackendService to route traffic to.
	ServiceName *string `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
	Weight *int `pulumi:"weight"`
}

type GrpcRouteRuleActionDestinationArgs added in v6.56.0 

type GrpcRouteRuleActionDestinationArgs struct {
	// The URL of a BackendService to route traffic to.
	ServiceName pulumi.StringPtrInput `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

func (GrpcRouteRuleActionDestinationArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleActionDestinationArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionDestinationArgs) ToGrpcRouteRuleActionDestinationOutput added in v6.56.0 

func (i GrpcRouteRuleActionDestinationArgs) ToGrpcRouteRuleActionDestinationOutput() GrpcRouteRuleActionDestinationOutput

func (GrpcRouteRuleActionDestinationArgs) ToGrpcRouteRuleActionDestinationOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionDestinationArgs) ToGrpcRouteRuleActionDestinationOutputWithContext(ctx context.Context) GrpcRouteRuleActionDestinationOutput

type GrpcRouteRuleActionDestinationArray added in v6.56.0 

type GrpcRouteRuleActionDestinationArray []GrpcRouteRuleActionDestinationInput

func (GrpcRouteRuleActionDestinationArray) ElementType added in v6.56.0 

func (GrpcRouteRuleActionDestinationArray) ElementType() reflect.Type

func (GrpcRouteRuleActionDestinationArray) ToGrpcRouteRuleActionDestinationArrayOutput added in v6.56.0 

func (i GrpcRouteRuleActionDestinationArray) ToGrpcRouteRuleActionDestinationArrayOutput() GrpcRouteRuleActionDestinationArrayOutput

func (GrpcRouteRuleActionDestinationArray) ToGrpcRouteRuleActionDestinationArrayOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionDestinationArray) ToGrpcRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) GrpcRouteRuleActionDestinationArrayOutput

type GrpcRouteRuleActionDestinationArrayInput added in v6.56.0 

type GrpcRouteRuleActionDestinationArrayInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionDestinationArrayOutput() GrpcRouteRuleActionDestinationArrayOutput
	ToGrpcRouteRuleActionDestinationArrayOutputWithContext(context.Context) GrpcRouteRuleActionDestinationArrayOutput
}

GrpcRouteRuleActionDestinationArrayInput is an input type that accepts GrpcRouteRuleActionDestinationArray and GrpcRouteRuleActionDestinationArrayOutput values. You can construct a concrete instance of `GrpcRouteRuleActionDestinationArrayInput` via: 

GrpcRouteRuleActionDestinationArray{ GrpcRouteRuleActionDestinationArgs{...} }

type GrpcRouteRuleActionDestinationArrayOutput added in v6.56.0 

type GrpcRouteRuleActionDestinationArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionDestinationArrayOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionDestinationArrayOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionDestinationArrayOutput) Index added in v6.56.0 

func (o GrpcRouteRuleActionDestinationArrayOutput) Index(i pulumi.IntInput) GrpcRouteRuleActionDestinationOutput

func (GrpcRouteRuleActionDestinationArrayOutput) ToGrpcRouteRuleActionDestinationArrayOutput added in v6.56.0 

func (o GrpcRouteRuleActionDestinationArrayOutput) ToGrpcRouteRuleActionDestinationArrayOutput() GrpcRouteRuleActionDestinationArrayOutput

func (GrpcRouteRuleActionDestinationArrayOutput) ToGrpcRouteRuleActionDestinationArrayOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionDestinationArrayOutput) ToGrpcRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) GrpcRouteRuleActionDestinationArrayOutput

type GrpcRouteRuleActionDestinationInput added in v6.56.0 

type GrpcRouteRuleActionDestinationInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionDestinationOutput() GrpcRouteRuleActionDestinationOutput
	ToGrpcRouteRuleActionDestinationOutputWithContext(context.Context) GrpcRouteRuleActionDestinationOutput
}

GrpcRouteRuleActionDestinationInput is an input type that accepts GrpcRouteRuleActionDestinationArgs and GrpcRouteRuleActionDestinationOutput values. You can construct a concrete instance of `GrpcRouteRuleActionDestinationInput` via: 

GrpcRouteRuleActionDestinationArgs{...}

type GrpcRouteRuleActionDestinationOutput added in v6.56.0 

type GrpcRouteRuleActionDestinationOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionDestinationOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionDestinationOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionDestinationOutput) ServiceName added in v6.56.0 

func (o GrpcRouteRuleActionDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (GrpcRouteRuleActionDestinationOutput) ToGrpcRouteRuleActionDestinationOutput added in v6.56.0 

func (o GrpcRouteRuleActionDestinationOutput) ToGrpcRouteRuleActionDestinationOutput() GrpcRouteRuleActionDestinationOutput

func (GrpcRouteRuleActionDestinationOutput) ToGrpcRouteRuleActionDestinationOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionDestinationOutput) ToGrpcRouteRuleActionDestinationOutputWithContext(ctx context.Context) GrpcRouteRuleActionDestinationOutput

func (GrpcRouteRuleActionDestinationOutput) Weight added in v6.56.0 

func (o GrpcRouteRuleActionDestinationOutput) Weight() pulumi.IntPtrOutput

Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.

type GrpcRouteRuleActionFaultInjectionPolicy added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicy struct {
	// Specification of how client requests are aborted as part of fault injection before being sent to a destination.
	// Structure is documented below.
	Abort *GrpcRouteRuleActionFaultInjectionPolicyAbort `pulumi:"abort"`
	// Specification of how client requests are delayed as part of fault injection before being sent to a destination.
	// Structure is documented below.
	Delay *GrpcRouteRuleActionFaultInjectionPolicyDelay `pulumi:"delay"`
}

type GrpcRouteRuleActionFaultInjectionPolicyAbort added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyAbort struct {
	// The HTTP status code used to abort the request.
	HttpStatus *int `pulumi:"httpStatus"`
	// The percentage of traffic which will be aborted.
	Percentage *int `pulumi:"percentage"`
}

type GrpcRouteRuleActionFaultInjectionPolicyAbortArgs added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyAbortArgs struct {
	// The HTTP status code used to abort the request.
	HttpStatus pulumi.IntPtrInput `pulumi:"httpStatus"`
	// The percentage of traffic which will be aborted.
	Percentage pulumi.IntPtrInput `pulumi:"percentage"`
}

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyAbortOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

type GrpcRouteRuleActionFaultInjectionPolicyAbortInput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyAbortInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortOutput
	ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutputWithContext(context.Context) GrpcRouteRuleActionFaultInjectionPolicyAbortOutput
}

GrpcRouteRuleActionFaultInjectionPolicyAbortInput is an input type that accepts GrpcRouteRuleActionFaultInjectionPolicyAbortArgs and GrpcRouteRuleActionFaultInjectionPolicyAbortOutput values. You can construct a concrete instance of `GrpcRouteRuleActionFaultInjectionPolicyAbortInput` via: 

GrpcRouteRuleActionFaultInjectionPolicyAbortArgs{...}

type GrpcRouteRuleActionFaultInjectionPolicyAbortOutput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyAbortOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) HttpStatus added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) HttpStatus() pulumi.IntPtrOutput

The HTTP status code used to abort the request.

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) Percentage added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic which will be aborted.

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyAbortOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

type GrpcRouteRuleActionFaultInjectionPolicyAbortPtrInput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyAbortPtrInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput
	ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext(context.Context) GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput
}

GrpcRouteRuleActionFaultInjectionPolicyAbortPtrInput is an input type that accepts GrpcRouteRuleActionFaultInjectionPolicyAbortArgs, GrpcRouteRuleActionFaultInjectionPolicyAbortPtr and GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput values. You can construct a concrete instance of `GrpcRouteRuleActionFaultInjectionPolicyAbortPtrInput` via: 

        GrpcRouteRuleActionFaultInjectionPolicyAbortArgs{...}

or:

        nil

func GrpcRouteRuleActionFaultInjectionPolicyAbortPtr added in v6.56.0 

func GrpcRouteRuleActionFaultInjectionPolicyAbortPtr(v *GrpcRouteRuleActionFaultInjectionPolicyAbortArgs) GrpcRouteRuleActionFaultInjectionPolicyAbortPtrInput

type GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Elem added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Elem() GrpcRouteRuleActionFaultInjectionPolicyAbortOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) HttpStatus added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) HttpStatus() pulumi.IntPtrOutput

The HTTP status code used to abort the request.

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Percentage added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic which will be aborted.

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

type GrpcRouteRuleActionFaultInjectionPolicyArgs added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyArgs struct {
	// Specification of how client requests are aborted as part of fault injection before being sent to a destination.
	// Structure is documented below.
	Abort GrpcRouteRuleActionFaultInjectionPolicyAbortPtrInput `pulumi:"abort"`
	// Specification of how client requests are delayed as part of fault injection before being sent to a destination.
	// Structure is documented below.
	Delay GrpcRouteRuleActionFaultInjectionPolicyDelayPtrInput `pulumi:"delay"`
}

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyOutput added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyOutput() GrpcRouteRuleActionFaultInjectionPolicyOutput

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyOutput

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyArgs) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

type GrpcRouteRuleActionFaultInjectionPolicyDelay added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyDelay struct {
	// Specify a fixed delay before forwarding the request.
	FixedDelay *string `pulumi:"fixedDelay"`
	// The percentage of traffic on which delay will be injected.
	Percentage *int `pulumi:"percentage"`
}

type GrpcRouteRuleActionFaultInjectionPolicyDelayArgs added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyDelayArgs struct {
	// Specify a fixed delay before forwarding the request.
	FixedDelay pulumi.StringPtrInput `pulumi:"fixedDelay"`
	// The percentage of traffic on which delay will be injected.
	Percentage pulumi.IntPtrInput `pulumi:"percentage"`
}

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyDelayOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

type GrpcRouteRuleActionFaultInjectionPolicyDelayInput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyDelayInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayOutput
	ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutputWithContext(context.Context) GrpcRouteRuleActionFaultInjectionPolicyDelayOutput
}

GrpcRouteRuleActionFaultInjectionPolicyDelayInput is an input type that accepts GrpcRouteRuleActionFaultInjectionPolicyDelayArgs and GrpcRouteRuleActionFaultInjectionPolicyDelayOutput values. You can construct a concrete instance of `GrpcRouteRuleActionFaultInjectionPolicyDelayInput` via: 

GrpcRouteRuleActionFaultInjectionPolicyDelayArgs{...}

type GrpcRouteRuleActionFaultInjectionPolicyDelayOutput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyDelayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) FixedDelay added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) FixedDelay() pulumi.StringPtrOutput

Specify a fixed delay before forwarding the request.

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) Percentage added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic on which delay will be injected.

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyDelayOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

type GrpcRouteRuleActionFaultInjectionPolicyDelayPtrInput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyDelayPtrInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput
	ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext(context.Context) GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput
}

GrpcRouteRuleActionFaultInjectionPolicyDelayPtrInput is an input type that accepts GrpcRouteRuleActionFaultInjectionPolicyDelayArgs, GrpcRouteRuleActionFaultInjectionPolicyDelayPtr and GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput values. You can construct a concrete instance of `GrpcRouteRuleActionFaultInjectionPolicyDelayPtrInput` via: 

        GrpcRouteRuleActionFaultInjectionPolicyDelayArgs{...}

or:

        nil

func GrpcRouteRuleActionFaultInjectionPolicyDelayPtr added in v6.56.0 

func GrpcRouteRuleActionFaultInjectionPolicyDelayPtr(v *GrpcRouteRuleActionFaultInjectionPolicyDelayArgs) GrpcRouteRuleActionFaultInjectionPolicyDelayPtrInput

type GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Elem added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Elem() GrpcRouteRuleActionFaultInjectionPolicyDelayOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) FixedDelay added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) FixedDelay() pulumi.StringPtrOutput

Specify a fixed delay before forwarding the request.

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Percentage added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic on which delay will be injected.

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

type GrpcRouteRuleActionFaultInjectionPolicyInput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionFaultInjectionPolicyOutput() GrpcRouteRuleActionFaultInjectionPolicyOutput
	ToGrpcRouteRuleActionFaultInjectionPolicyOutputWithContext(context.Context) GrpcRouteRuleActionFaultInjectionPolicyOutput
}

GrpcRouteRuleActionFaultInjectionPolicyInput is an input type that accepts GrpcRouteRuleActionFaultInjectionPolicyArgs and GrpcRouteRuleActionFaultInjectionPolicyOutput values. You can construct a concrete instance of `GrpcRouteRuleActionFaultInjectionPolicyInput` via: 

GrpcRouteRuleActionFaultInjectionPolicyArgs{...}

type GrpcRouteRuleActionFaultInjectionPolicyOutput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) Abort added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyOutput) Abort() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

Specification of how client requests are aborted as part of fault injection before being sent to a destination. Structure is documented below.

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) Delay added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyOutput) Delay() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

Specification of how client requests are delayed as part of fault injection before being sent to a destination. Structure is documented below.

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyOutput() GrpcRouteRuleActionFaultInjectionPolicyOutput

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyOutput

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

type GrpcRouteRuleActionFaultInjectionPolicyPtrInput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyPtrInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput
	ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext(context.Context) GrpcRouteRuleActionFaultInjectionPolicyPtrOutput
}

GrpcRouteRuleActionFaultInjectionPolicyPtrInput is an input type that accepts GrpcRouteRuleActionFaultInjectionPolicyArgs, GrpcRouteRuleActionFaultInjectionPolicyPtr and GrpcRouteRuleActionFaultInjectionPolicyPtrOutput values. You can construct a concrete instance of `GrpcRouteRuleActionFaultInjectionPolicyPtrInput` via: 

        GrpcRouteRuleActionFaultInjectionPolicyArgs{...}

or:

        nil

func GrpcRouteRuleActionFaultInjectionPolicyPtr added in v6.56.0 

func GrpcRouteRuleActionFaultInjectionPolicyPtr(v *GrpcRouteRuleActionFaultInjectionPolicyArgs) GrpcRouteRuleActionFaultInjectionPolicyPtrInput

type GrpcRouteRuleActionFaultInjectionPolicyPtrOutput added in v6.56.0 

type GrpcRouteRuleActionFaultInjectionPolicyPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) Abort added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) Abort() GrpcRouteRuleActionFaultInjectionPolicyAbortPtrOutput

Specification of how client requests are aborted as part of fault injection before being sent to a destination. Structure is documented below.

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) Delay added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) Delay() GrpcRouteRuleActionFaultInjectionPolicyDelayPtrOutput

Specification of how client requests are delayed as part of fault injection before being sent to a destination. Structure is documented below.

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) Elem added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) Elem() GrpcRouteRuleActionFaultInjectionPolicyOutput

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutput() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

func (GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionFaultInjectionPolicyPtrOutput) ToGrpcRouteRuleActionFaultInjectionPolicyPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

type GrpcRouteRuleActionInput added in v6.56.0 

type GrpcRouteRuleActionInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionOutput() GrpcRouteRuleActionOutput
	ToGrpcRouteRuleActionOutputWithContext(context.Context) GrpcRouteRuleActionOutput
}

GrpcRouteRuleActionInput is an input type that accepts GrpcRouteRuleActionArgs and GrpcRouteRuleActionOutput values. You can construct a concrete instance of `GrpcRouteRuleActionInput` via: 

GrpcRouteRuleActionArgs{...}

type GrpcRouteRuleActionOutput added in v6.56.0 

type GrpcRouteRuleActionOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionOutput) Destinations added in v6.56.0 

func (o GrpcRouteRuleActionOutput) Destinations() GrpcRouteRuleActionDestinationArrayOutput

The destination to which traffic should be forwarded. Structure is documented below.

func (GrpcRouteRuleActionOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionOutput) FaultInjectionPolicy added in v6.56.0 

func (o GrpcRouteRuleActionOutput) FaultInjectionPolicy() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure. Structure is documented below.

func (GrpcRouteRuleActionOutput) RetryPolicy added in v6.56.0 

func (o GrpcRouteRuleActionOutput) RetryPolicy() GrpcRouteRuleActionRetryPolicyPtrOutput

Specifies the retry policy associated with this route. Structure is documented below.

func (GrpcRouteRuleActionOutput) Timeout added in v6.56.0 

func (o GrpcRouteRuleActionOutput) Timeout() pulumi.StringPtrOutput

Specifies the timeout for selected route.

func (GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionOutput added in v6.56.0 

func (o GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionOutput() GrpcRouteRuleActionOutput

func (GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionOutputWithContext(ctx context.Context) GrpcRouteRuleActionOutput

func (GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionPtrOutput() GrpcRouteRuleActionPtrOutput

func (GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionOutput) ToGrpcRouteRuleActionPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionPtrOutput

type GrpcRouteRuleActionPtrInput added in v6.56.0 

type GrpcRouteRuleActionPtrInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionPtrOutput() GrpcRouteRuleActionPtrOutput
	ToGrpcRouteRuleActionPtrOutputWithContext(context.Context) GrpcRouteRuleActionPtrOutput
}

GrpcRouteRuleActionPtrInput is an input type that accepts GrpcRouteRuleActionArgs, GrpcRouteRuleActionPtr and GrpcRouteRuleActionPtrOutput values. You can construct a concrete instance of `GrpcRouteRuleActionPtrInput` via: 

        GrpcRouteRuleActionArgs{...}

or:

        nil

func GrpcRouteRuleActionPtr added in v6.56.0 

func GrpcRouteRuleActionPtr(v *GrpcRouteRuleActionArgs) GrpcRouteRuleActionPtrInput

type GrpcRouteRuleActionPtrOutput added in v6.56.0 

type GrpcRouteRuleActionPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionPtrOutput) Destinations added in v6.56.0 

func (o GrpcRouteRuleActionPtrOutput) Destinations() GrpcRouteRuleActionDestinationArrayOutput

The destination to which traffic should be forwarded. Structure is documented below.

func (GrpcRouteRuleActionPtrOutput) Elem added in v6.56.0 

func (o GrpcRouteRuleActionPtrOutput) Elem() GrpcRouteRuleActionOutput

func (GrpcRouteRuleActionPtrOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionPtrOutput) FaultInjectionPolicy added in v6.56.0 

func (o GrpcRouteRuleActionPtrOutput) FaultInjectionPolicy() GrpcRouteRuleActionFaultInjectionPolicyPtrOutput

The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure. Structure is documented below.

func (GrpcRouteRuleActionPtrOutput) RetryPolicy added in v6.56.0 

func (o GrpcRouteRuleActionPtrOutput) RetryPolicy() GrpcRouteRuleActionRetryPolicyPtrOutput

Specifies the retry policy associated with this route. Structure is documented below.

func (GrpcRouteRuleActionPtrOutput) Timeout added in v6.56.0 

func (o GrpcRouteRuleActionPtrOutput) Timeout() pulumi.StringPtrOutput

Specifies the timeout for selected route.

func (GrpcRouteRuleActionPtrOutput) ToGrpcRouteRuleActionPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionPtrOutput) ToGrpcRouteRuleActionPtrOutput() GrpcRouteRuleActionPtrOutput

func (GrpcRouteRuleActionPtrOutput) ToGrpcRouteRuleActionPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionPtrOutput) ToGrpcRouteRuleActionPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionPtrOutput

type GrpcRouteRuleActionRetryPolicy added in v6.56.0 

type GrpcRouteRuleActionRetryPolicy struct {
	// Specifies the allowed number of retries.
	//
	// ***
	NumRetries *int `pulumi:"numRetries"`
	// Specifies one or more conditions when this retry policy applies.
	// Each value may be one of: `connect-failure`, `refused-stream`, `cancelled`, `deadline-exceeded`, `resource-exhausted`, `unavailable`.
	RetryConditions []string `pulumi:"retryConditions"`
}

type GrpcRouteRuleActionRetryPolicyArgs added in v6.56.0 

type GrpcRouteRuleActionRetryPolicyArgs struct {
	// Specifies the allowed number of retries.
	//
	// ***
	NumRetries pulumi.IntPtrInput `pulumi:"numRetries"`
	// Specifies one or more conditions when this retry policy applies.
	// Each value may be one of: `connect-failure`, `refused-stream`, `cancelled`, `deadline-exceeded`, `resource-exhausted`, `unavailable`.
	RetryConditions pulumi.StringArrayInput `pulumi:"retryConditions"`
}

func (GrpcRouteRuleActionRetryPolicyArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleActionRetryPolicyArgs) ElementType() reflect.Type

func (GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyOutput added in v6.56.0 

func (i GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyOutput() GrpcRouteRuleActionRetryPolicyOutput

func (GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyOutputWithContext(ctx context.Context) GrpcRouteRuleActionRetryPolicyOutput

func (GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyPtrOutput added in v6.56.0 

func (i GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyPtrOutput() GrpcRouteRuleActionRetryPolicyPtrOutput

func (GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleActionRetryPolicyArgs) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionRetryPolicyPtrOutput

type GrpcRouteRuleActionRetryPolicyInput added in v6.56.0 

type GrpcRouteRuleActionRetryPolicyInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionRetryPolicyOutput() GrpcRouteRuleActionRetryPolicyOutput
	ToGrpcRouteRuleActionRetryPolicyOutputWithContext(context.Context) GrpcRouteRuleActionRetryPolicyOutput
}

GrpcRouteRuleActionRetryPolicyInput is an input type that accepts GrpcRouteRuleActionRetryPolicyArgs and GrpcRouteRuleActionRetryPolicyOutput values. You can construct a concrete instance of `GrpcRouteRuleActionRetryPolicyInput` via: 

GrpcRouteRuleActionRetryPolicyArgs{...}

type GrpcRouteRuleActionRetryPolicyOutput added in v6.56.0 

type GrpcRouteRuleActionRetryPolicyOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionRetryPolicyOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionRetryPolicyOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionRetryPolicyOutput) NumRetries added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyOutput) NumRetries() pulumi.IntPtrOutput

Specifies the allowed number of retries.

***

func (GrpcRouteRuleActionRetryPolicyOutput) RetryConditions added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyOutput) RetryConditions() pulumi.StringArrayOutput

Specifies one or more conditions when this retry policy applies. Each value may be one of: `connect-failure`, `refused-stream`, `cancelled`, `deadline-exceeded`, `resource-exhausted`, `unavailable`.

func (GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyOutput added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyOutput() GrpcRouteRuleActionRetryPolicyOutput

func (GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyOutputWithContext(ctx context.Context) GrpcRouteRuleActionRetryPolicyOutput

func (GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutput() GrpcRouteRuleActionRetryPolicyPtrOutput

func (GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionRetryPolicyPtrOutput

type GrpcRouteRuleActionRetryPolicyPtrInput added in v6.56.0 

type GrpcRouteRuleActionRetryPolicyPtrInput interface {
	pulumi.Input

	ToGrpcRouteRuleActionRetryPolicyPtrOutput() GrpcRouteRuleActionRetryPolicyPtrOutput
	ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext(context.Context) GrpcRouteRuleActionRetryPolicyPtrOutput
}

GrpcRouteRuleActionRetryPolicyPtrInput is an input type that accepts GrpcRouteRuleActionRetryPolicyArgs, GrpcRouteRuleActionRetryPolicyPtr and GrpcRouteRuleActionRetryPolicyPtrOutput values. You can construct a concrete instance of `GrpcRouteRuleActionRetryPolicyPtrInput` via: 

        GrpcRouteRuleActionRetryPolicyArgs{...}

or:

        nil

func GrpcRouteRuleActionRetryPolicyPtr added in v6.56.0 

func GrpcRouteRuleActionRetryPolicyPtr(v *GrpcRouteRuleActionRetryPolicyArgs) GrpcRouteRuleActionRetryPolicyPtrInput

type GrpcRouteRuleActionRetryPolicyPtrOutput added in v6.56.0 

type GrpcRouteRuleActionRetryPolicyPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleActionRetryPolicyPtrOutput) Elem added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyPtrOutput) Elem() GrpcRouteRuleActionRetryPolicyOutput

func (GrpcRouteRuleActionRetryPolicyPtrOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleActionRetryPolicyPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleActionRetryPolicyPtrOutput) NumRetries added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyPtrOutput) NumRetries() pulumi.IntPtrOutput

Specifies the allowed number of retries.

***

func (GrpcRouteRuleActionRetryPolicyPtrOutput) RetryConditions added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyPtrOutput) RetryConditions() pulumi.StringArrayOutput

Specifies one or more conditions when this retry policy applies. Each value may be one of: `connect-failure`, `refused-stream`, `cancelled`, `deadline-exceeded`, `resource-exhausted`, `unavailable`.

func (GrpcRouteRuleActionRetryPolicyPtrOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutput added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyPtrOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutput() GrpcRouteRuleActionRetryPolicyPtrOutput

func (GrpcRouteRuleActionRetryPolicyPtrOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleActionRetryPolicyPtrOutput) ToGrpcRouteRuleActionRetryPolicyPtrOutputWithContext(ctx context.Context) GrpcRouteRuleActionRetryPolicyPtrOutput

type GrpcRouteRuleArgs added in v6.56.0 

type GrpcRouteRuleArgs struct {
	// Required. A detailed rule defining how to route traffic.
	// Structure is documented below.
	Action GrpcRouteRuleActionPtrInput `pulumi:"action"`
	// Matches define conditions used for matching the rule against incoming gRPC requests.
	// Structure is documented below.
	Matches GrpcRouteRuleMatchArrayInput `pulumi:"matches"`
}

func (GrpcRouteRuleArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleArgs) ElementType() reflect.Type

func (GrpcRouteRuleArgs) ToGrpcRouteRuleOutput added in v6.56.0 

func (i GrpcRouteRuleArgs) ToGrpcRouteRuleOutput() GrpcRouteRuleOutput

func (GrpcRouteRuleArgs) ToGrpcRouteRuleOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleArgs) ToGrpcRouteRuleOutputWithContext(ctx context.Context) GrpcRouteRuleOutput

type GrpcRouteRuleArray added in v6.56.0 

type GrpcRouteRuleArray []GrpcRouteRuleInput

func (GrpcRouteRuleArray) ElementType added in v6.56.0 

func (GrpcRouteRuleArray) ElementType() reflect.Type

func (GrpcRouteRuleArray) ToGrpcRouteRuleArrayOutput added in v6.56.0 

func (i GrpcRouteRuleArray) ToGrpcRouteRuleArrayOutput() GrpcRouteRuleArrayOutput

func (GrpcRouteRuleArray) ToGrpcRouteRuleArrayOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleArray) ToGrpcRouteRuleArrayOutputWithContext(ctx context.Context) GrpcRouteRuleArrayOutput

type GrpcRouteRuleArrayInput added in v6.56.0 

type GrpcRouteRuleArrayInput interface {
	pulumi.Input

	ToGrpcRouteRuleArrayOutput() GrpcRouteRuleArrayOutput
	ToGrpcRouteRuleArrayOutputWithContext(context.Context) GrpcRouteRuleArrayOutput
}

GrpcRouteRuleArrayInput is an input type that accepts GrpcRouteRuleArray and GrpcRouteRuleArrayOutput values. You can construct a concrete instance of `GrpcRouteRuleArrayInput` via: 

GrpcRouteRuleArray{ GrpcRouteRuleArgs{...} }

type GrpcRouteRuleArrayOutput added in v6.56.0 

type GrpcRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleArrayOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleArrayOutput) ElementType() reflect.Type

func (GrpcRouteRuleArrayOutput) Index added in v6.56.0 

func (o GrpcRouteRuleArrayOutput) Index(i pulumi.IntInput) GrpcRouteRuleOutput

func (GrpcRouteRuleArrayOutput) ToGrpcRouteRuleArrayOutput added in v6.56.0 

func (o GrpcRouteRuleArrayOutput) ToGrpcRouteRuleArrayOutput() GrpcRouteRuleArrayOutput

func (GrpcRouteRuleArrayOutput) ToGrpcRouteRuleArrayOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleArrayOutput) ToGrpcRouteRuleArrayOutputWithContext(ctx context.Context) GrpcRouteRuleArrayOutput

type GrpcRouteRuleInput added in v6.56.0 

type GrpcRouteRuleInput interface {
	pulumi.Input

	ToGrpcRouteRuleOutput() GrpcRouteRuleOutput
	ToGrpcRouteRuleOutputWithContext(context.Context) GrpcRouteRuleOutput
}

GrpcRouteRuleInput is an input type that accepts GrpcRouteRuleArgs and GrpcRouteRuleOutput values. You can construct a concrete instance of `GrpcRouteRuleInput` via: 

GrpcRouteRuleArgs{...}

type GrpcRouteRuleMatch added in v6.56.0 

type GrpcRouteRuleMatch struct {
	// Specifies a list of HTTP request headers to match against.
	// Structure is documented below.
	Headers []GrpcRouteRuleMatchHeader `pulumi:"headers"`
	// A gRPC method to match against. If this field is empty or omitted, will match all methods.
	// Structure is documented below.
	Method *GrpcRouteRuleMatchMethod `pulumi:"method"`
}

type GrpcRouteRuleMatchArgs added in v6.56.0 

type GrpcRouteRuleMatchArgs struct {
	// Specifies a list of HTTP request headers to match against.
	// Structure is documented below.
	Headers GrpcRouteRuleMatchHeaderArrayInput `pulumi:"headers"`
	// A gRPC method to match against. If this field is empty or omitted, will match all methods.
	// Structure is documented below.
	Method GrpcRouteRuleMatchMethodPtrInput `pulumi:"method"`
}

func (GrpcRouteRuleMatchArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchArgs) ElementType() reflect.Type

func (GrpcRouteRuleMatchArgs) ToGrpcRouteRuleMatchOutput added in v6.56.0 

func (i GrpcRouteRuleMatchArgs) ToGrpcRouteRuleMatchOutput() GrpcRouteRuleMatchOutput

func (GrpcRouteRuleMatchArgs) ToGrpcRouteRuleMatchOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleMatchArgs) ToGrpcRouteRuleMatchOutputWithContext(ctx context.Context) GrpcRouteRuleMatchOutput

type GrpcRouteRuleMatchArray added in v6.56.0 

type GrpcRouteRuleMatchArray []GrpcRouteRuleMatchInput

func (GrpcRouteRuleMatchArray) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchArray) ElementType() reflect.Type

func (GrpcRouteRuleMatchArray) ToGrpcRouteRuleMatchArrayOutput added in v6.56.0 

func (i GrpcRouteRuleMatchArray) ToGrpcRouteRuleMatchArrayOutput() GrpcRouteRuleMatchArrayOutput

func (GrpcRouteRuleMatchArray) ToGrpcRouteRuleMatchArrayOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleMatchArray) ToGrpcRouteRuleMatchArrayOutputWithContext(ctx context.Context) GrpcRouteRuleMatchArrayOutput

type GrpcRouteRuleMatchArrayInput added in v6.56.0 

type GrpcRouteRuleMatchArrayInput interface {
	pulumi.Input

	ToGrpcRouteRuleMatchArrayOutput() GrpcRouteRuleMatchArrayOutput
	ToGrpcRouteRuleMatchArrayOutputWithContext(context.Context) GrpcRouteRuleMatchArrayOutput
}

GrpcRouteRuleMatchArrayInput is an input type that accepts GrpcRouteRuleMatchArray and GrpcRouteRuleMatchArrayOutput values. You can construct a concrete instance of `GrpcRouteRuleMatchArrayInput` via: 

GrpcRouteRuleMatchArray{ GrpcRouteRuleMatchArgs{...} }

type GrpcRouteRuleMatchArrayOutput added in v6.56.0 

type GrpcRouteRuleMatchArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchArrayOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchArrayOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchArrayOutput) Index added in v6.56.0 

func (o GrpcRouteRuleMatchArrayOutput) Index(i pulumi.IntInput) GrpcRouteRuleMatchOutput

func (GrpcRouteRuleMatchArrayOutput) ToGrpcRouteRuleMatchArrayOutput added in v6.56.0 

func (o GrpcRouteRuleMatchArrayOutput) ToGrpcRouteRuleMatchArrayOutput() GrpcRouteRuleMatchArrayOutput

func (GrpcRouteRuleMatchArrayOutput) ToGrpcRouteRuleMatchArrayOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleMatchArrayOutput) ToGrpcRouteRuleMatchArrayOutputWithContext(ctx context.Context) GrpcRouteRuleMatchArrayOutput

type GrpcRouteRuleMatchHeader added in v6.56.0 

type GrpcRouteRuleMatchHeader struct {
	// Required. The key of the header.
	Key string `pulumi:"key"`
	// The type of match.
	// Default value is `EXACT`.
	// Possible values are: `TYPE_UNSPECIFIED`, `EXACT`, `REGULAR_EXPRESSION`.
	Type *string `pulumi:"type"`
	// Required. The value of the header.
	Value string `pulumi:"value"`
}

type GrpcRouteRuleMatchHeaderArgs added in v6.56.0 

type GrpcRouteRuleMatchHeaderArgs struct {
	// Required. The key of the header.
	Key pulumi.StringInput `pulumi:"key"`
	// The type of match.
	// Default value is `EXACT`.
	// Possible values are: `TYPE_UNSPECIFIED`, `EXACT`, `REGULAR_EXPRESSION`.
	Type pulumi.StringPtrInput `pulumi:"type"`
	// Required. The value of the header.
	Value pulumi.StringInput `pulumi:"value"`
}

func (GrpcRouteRuleMatchHeaderArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchHeaderArgs) ElementType() reflect.Type

func (GrpcRouteRuleMatchHeaderArgs) ToGrpcRouteRuleMatchHeaderOutput added in v6.56.0 

func (i GrpcRouteRuleMatchHeaderArgs) ToGrpcRouteRuleMatchHeaderOutput() GrpcRouteRuleMatchHeaderOutput

func (GrpcRouteRuleMatchHeaderArgs) ToGrpcRouteRuleMatchHeaderOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleMatchHeaderArgs) ToGrpcRouteRuleMatchHeaderOutputWithContext(ctx context.Context) GrpcRouteRuleMatchHeaderOutput

type GrpcRouteRuleMatchHeaderArray added in v6.56.0 

type GrpcRouteRuleMatchHeaderArray []GrpcRouteRuleMatchHeaderInput

func (GrpcRouteRuleMatchHeaderArray) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchHeaderArray) ElementType() reflect.Type

func (GrpcRouteRuleMatchHeaderArray) ToGrpcRouteRuleMatchHeaderArrayOutput added in v6.56.0 

func (i GrpcRouteRuleMatchHeaderArray) ToGrpcRouteRuleMatchHeaderArrayOutput() GrpcRouteRuleMatchHeaderArrayOutput

func (GrpcRouteRuleMatchHeaderArray) ToGrpcRouteRuleMatchHeaderArrayOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleMatchHeaderArray) ToGrpcRouteRuleMatchHeaderArrayOutputWithContext(ctx context.Context) GrpcRouteRuleMatchHeaderArrayOutput

type GrpcRouteRuleMatchHeaderArrayInput added in v6.56.0 

type GrpcRouteRuleMatchHeaderArrayInput interface {
	pulumi.Input

	ToGrpcRouteRuleMatchHeaderArrayOutput() GrpcRouteRuleMatchHeaderArrayOutput
	ToGrpcRouteRuleMatchHeaderArrayOutputWithContext(context.Context) GrpcRouteRuleMatchHeaderArrayOutput
}

GrpcRouteRuleMatchHeaderArrayInput is an input type that accepts GrpcRouteRuleMatchHeaderArray and GrpcRouteRuleMatchHeaderArrayOutput values. You can construct a concrete instance of `GrpcRouteRuleMatchHeaderArrayInput` via: 

GrpcRouteRuleMatchHeaderArray{ GrpcRouteRuleMatchHeaderArgs{...} }

type GrpcRouteRuleMatchHeaderArrayOutput added in v6.56.0 

type GrpcRouteRuleMatchHeaderArrayOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchHeaderArrayOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchHeaderArrayOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchHeaderArrayOutput) Index added in v6.56.0 

func (o GrpcRouteRuleMatchHeaderArrayOutput) Index(i pulumi.IntInput) GrpcRouteRuleMatchHeaderOutput

func (GrpcRouteRuleMatchHeaderArrayOutput) ToGrpcRouteRuleMatchHeaderArrayOutput added in v6.56.0 

func (o GrpcRouteRuleMatchHeaderArrayOutput) ToGrpcRouteRuleMatchHeaderArrayOutput() GrpcRouteRuleMatchHeaderArrayOutput

func (GrpcRouteRuleMatchHeaderArrayOutput) ToGrpcRouteRuleMatchHeaderArrayOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleMatchHeaderArrayOutput) ToGrpcRouteRuleMatchHeaderArrayOutputWithContext(ctx context.Context) GrpcRouteRuleMatchHeaderArrayOutput

type GrpcRouteRuleMatchHeaderInput added in v6.56.0 

type GrpcRouteRuleMatchHeaderInput interface {
	pulumi.Input

	ToGrpcRouteRuleMatchHeaderOutput() GrpcRouteRuleMatchHeaderOutput
	ToGrpcRouteRuleMatchHeaderOutputWithContext(context.Context) GrpcRouteRuleMatchHeaderOutput
}

GrpcRouteRuleMatchHeaderInput is an input type that accepts GrpcRouteRuleMatchHeaderArgs and GrpcRouteRuleMatchHeaderOutput values. You can construct a concrete instance of `GrpcRouteRuleMatchHeaderInput` via: 

GrpcRouteRuleMatchHeaderArgs{...}

type GrpcRouteRuleMatchHeaderOutput added in v6.56.0 

type GrpcRouteRuleMatchHeaderOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchHeaderOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchHeaderOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchHeaderOutput) Key added in v6.56.0 

func (o GrpcRouteRuleMatchHeaderOutput) Key() pulumi.StringOutput

Required. The key of the header.

func (GrpcRouteRuleMatchHeaderOutput) ToGrpcRouteRuleMatchHeaderOutput added in v6.56.0 

func (o GrpcRouteRuleMatchHeaderOutput) ToGrpcRouteRuleMatchHeaderOutput() GrpcRouteRuleMatchHeaderOutput

func (GrpcRouteRuleMatchHeaderOutput) ToGrpcRouteRuleMatchHeaderOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleMatchHeaderOutput) ToGrpcRouteRuleMatchHeaderOutputWithContext(ctx context.Context) GrpcRouteRuleMatchHeaderOutput

func (GrpcRouteRuleMatchHeaderOutput) Type added in v6.56.0 

func (o GrpcRouteRuleMatchHeaderOutput) Type() pulumi.StringPtrOutput

The type of match. Default value is `EXACT`. Possible values are: `TYPE_UNSPECIFIED`, `EXACT`, `REGULAR_EXPRESSION`.

func (GrpcRouteRuleMatchHeaderOutput) Value added in v6.56.0 

func (o GrpcRouteRuleMatchHeaderOutput) Value() pulumi.StringOutput

Required. The value of the header.

type GrpcRouteRuleMatchInput added in v6.56.0 

type GrpcRouteRuleMatchInput interface {
	pulumi.Input

	ToGrpcRouteRuleMatchOutput() GrpcRouteRuleMatchOutput
	ToGrpcRouteRuleMatchOutputWithContext(context.Context) GrpcRouteRuleMatchOutput
}

GrpcRouteRuleMatchInput is an input type that accepts GrpcRouteRuleMatchArgs and GrpcRouteRuleMatchOutput values. You can construct a concrete instance of `GrpcRouteRuleMatchInput` via: 

GrpcRouteRuleMatchArgs{...}

type GrpcRouteRuleMatchMethod added in v6.56.0 

type GrpcRouteRuleMatchMethod struct {
	// Specifies that matches are case sensitive. The default value is true.
	CaseSensitive *bool `pulumi:"caseSensitive"`
	// Required. Name of the method to match against.
	GrpcMethod string `pulumi:"grpcMethod"`
	// Required. Name of the service to match against.
	GrpcService string `pulumi:"grpcService"`
}

type GrpcRouteRuleMatchMethodArgs added in v6.56.0 

type GrpcRouteRuleMatchMethodArgs struct {
	// Specifies that matches are case sensitive. The default value is true.
	CaseSensitive pulumi.BoolPtrInput `pulumi:"caseSensitive"`
	// Required. Name of the method to match against.
	GrpcMethod pulumi.StringInput `pulumi:"grpcMethod"`
	// Required. Name of the service to match against.
	GrpcService pulumi.StringInput `pulumi:"grpcService"`
}

func (GrpcRouteRuleMatchMethodArgs) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchMethodArgs) ElementType() reflect.Type

func (GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodOutput added in v6.56.0 

func (i GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodOutput() GrpcRouteRuleMatchMethodOutput

func (GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodOutputWithContext(ctx context.Context) GrpcRouteRuleMatchMethodOutput

func (GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodPtrOutput added in v6.56.0 

func (i GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodPtrOutput() GrpcRouteRuleMatchMethodPtrOutput

func (GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodPtrOutputWithContext added in v6.56.0 

func (i GrpcRouteRuleMatchMethodArgs) ToGrpcRouteRuleMatchMethodPtrOutputWithContext(ctx context.Context) GrpcRouteRuleMatchMethodPtrOutput

type GrpcRouteRuleMatchMethodInput added in v6.56.0 

type GrpcRouteRuleMatchMethodInput interface {
	pulumi.Input

	ToGrpcRouteRuleMatchMethodOutput() GrpcRouteRuleMatchMethodOutput
	ToGrpcRouteRuleMatchMethodOutputWithContext(context.Context) GrpcRouteRuleMatchMethodOutput
}

GrpcRouteRuleMatchMethodInput is an input type that accepts GrpcRouteRuleMatchMethodArgs and GrpcRouteRuleMatchMethodOutput values. You can construct a concrete instance of `GrpcRouteRuleMatchMethodInput` via: 

GrpcRouteRuleMatchMethodArgs{...}

type GrpcRouteRuleMatchMethodOutput added in v6.56.0 

type GrpcRouteRuleMatchMethodOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchMethodOutput) CaseSensitive added in v6.56.0 

func (o GrpcRouteRuleMatchMethodOutput) CaseSensitive() pulumi.BoolPtrOutput

Specifies that matches are case sensitive. The default value is true.

func (GrpcRouteRuleMatchMethodOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchMethodOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchMethodOutput) GrpcMethod added in v6.56.0 

func (o GrpcRouteRuleMatchMethodOutput) GrpcMethod() pulumi.StringOutput

Required. Name of the method to match against.

func (GrpcRouteRuleMatchMethodOutput) GrpcService added in v6.56.0 

func (o GrpcRouteRuleMatchMethodOutput) GrpcService() pulumi.StringOutput

Required. Name of the service to match against.

func (GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodOutput added in v6.56.0 

func (o GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodOutput() GrpcRouteRuleMatchMethodOutput

func (GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodOutputWithContext(ctx context.Context) GrpcRouteRuleMatchMethodOutput

func (GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodPtrOutput added in v6.56.0 

func (o GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodPtrOutput() GrpcRouteRuleMatchMethodPtrOutput

func (GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleMatchMethodOutput) ToGrpcRouteRuleMatchMethodPtrOutputWithContext(ctx context.Context) GrpcRouteRuleMatchMethodPtrOutput

type GrpcRouteRuleMatchMethodPtrInput added in v6.56.0 

type GrpcRouteRuleMatchMethodPtrInput interface {
	pulumi.Input

	ToGrpcRouteRuleMatchMethodPtrOutput() GrpcRouteRuleMatchMethodPtrOutput
	ToGrpcRouteRuleMatchMethodPtrOutputWithContext(context.Context) GrpcRouteRuleMatchMethodPtrOutput
}

GrpcRouteRuleMatchMethodPtrInput is an input type that accepts GrpcRouteRuleMatchMethodArgs, GrpcRouteRuleMatchMethodPtr and GrpcRouteRuleMatchMethodPtrOutput values. You can construct a concrete instance of `GrpcRouteRuleMatchMethodPtrInput` via: 

        GrpcRouteRuleMatchMethodArgs{...}

or:

        nil

func GrpcRouteRuleMatchMethodPtr added in v6.56.0 

func GrpcRouteRuleMatchMethodPtr(v *GrpcRouteRuleMatchMethodArgs) GrpcRouteRuleMatchMethodPtrInput

type GrpcRouteRuleMatchMethodPtrOutput added in v6.56.0 

type GrpcRouteRuleMatchMethodPtrOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchMethodPtrOutput) CaseSensitive added in v6.56.0 

func (o GrpcRouteRuleMatchMethodPtrOutput) CaseSensitive() pulumi.BoolPtrOutput

Specifies that matches are case sensitive. The default value is true.

func (GrpcRouteRuleMatchMethodPtrOutput) Elem added in v6.56.0 

func (o GrpcRouteRuleMatchMethodPtrOutput) Elem() GrpcRouteRuleMatchMethodOutput

func (GrpcRouteRuleMatchMethodPtrOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchMethodPtrOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchMethodPtrOutput) GrpcMethod added in v6.56.0 

func (o GrpcRouteRuleMatchMethodPtrOutput) GrpcMethod() pulumi.StringPtrOutput

Required. Name of the method to match against.

func (GrpcRouteRuleMatchMethodPtrOutput) GrpcService added in v6.56.0 

func (o GrpcRouteRuleMatchMethodPtrOutput) GrpcService() pulumi.StringPtrOutput

Required. Name of the service to match against.

func (GrpcRouteRuleMatchMethodPtrOutput) ToGrpcRouteRuleMatchMethodPtrOutput added in v6.56.0 

func (o GrpcRouteRuleMatchMethodPtrOutput) ToGrpcRouteRuleMatchMethodPtrOutput() GrpcRouteRuleMatchMethodPtrOutput

func (GrpcRouteRuleMatchMethodPtrOutput) ToGrpcRouteRuleMatchMethodPtrOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleMatchMethodPtrOutput) ToGrpcRouteRuleMatchMethodPtrOutputWithContext(ctx context.Context) GrpcRouteRuleMatchMethodPtrOutput

type GrpcRouteRuleMatchOutput added in v6.56.0 

type GrpcRouteRuleMatchOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleMatchOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleMatchOutput) ElementType() reflect.Type

func (GrpcRouteRuleMatchOutput) Headers added in v6.56.0 

func (o GrpcRouteRuleMatchOutput) Headers() GrpcRouteRuleMatchHeaderArrayOutput

Specifies a list of HTTP request headers to match against. Structure is documented below.

func (GrpcRouteRuleMatchOutput) Method added in v6.56.0 

func (o GrpcRouteRuleMatchOutput) Method() GrpcRouteRuleMatchMethodPtrOutput

A gRPC method to match against. If this field is empty or omitted, will match all methods. Structure is documented below.

func (GrpcRouteRuleMatchOutput) ToGrpcRouteRuleMatchOutput added in v6.56.0 

func (o GrpcRouteRuleMatchOutput) ToGrpcRouteRuleMatchOutput() GrpcRouteRuleMatchOutput

func (GrpcRouteRuleMatchOutput) ToGrpcRouteRuleMatchOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleMatchOutput) ToGrpcRouteRuleMatchOutputWithContext(ctx context.Context) GrpcRouteRuleMatchOutput

type GrpcRouteRuleOutput added in v6.56.0 

type GrpcRouteRuleOutput struct{ *pulumi.OutputState }

func (GrpcRouteRuleOutput) Action added in v6.56.0 

func (o GrpcRouteRuleOutput) Action() GrpcRouteRuleActionPtrOutput

Required. A detailed rule defining how to route traffic. Structure is documented below.

func (GrpcRouteRuleOutput) ElementType added in v6.56.0 

func (GrpcRouteRuleOutput) ElementType() reflect.Type

func (GrpcRouteRuleOutput) Matches added in v6.56.0 

func (o GrpcRouteRuleOutput) Matches() GrpcRouteRuleMatchArrayOutput

Matches define conditions used for matching the rule against incoming gRPC requests. Structure is documented below.

func (GrpcRouteRuleOutput) ToGrpcRouteRuleOutput added in v6.56.0 

func (o GrpcRouteRuleOutput) ToGrpcRouteRuleOutput() GrpcRouteRuleOutput

func (GrpcRouteRuleOutput) ToGrpcRouteRuleOutputWithContext added in v6.56.0 

func (o GrpcRouteRuleOutput) ToGrpcRouteRuleOutputWithContext(ctx context.Context) GrpcRouteRuleOutput

type GrpcRouteState added in v6.56.0 

type GrpcRouteState struct {
	// Time the GrpcRoute was created in UTC.
	CreateTime pulumi.StringPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// List of gateways this GrpcRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	Gateways pulumi.StringArrayInput
	// Required. Service hostnames with an optional port for which this route describes traffic.
	Hostnames pulumi.StringArrayInput
	// Set of label tags associated with the GrpcRoute resource.
	Labels pulumi.StringMapInput
	// List of meshes this GrpcRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	Meshes pulumi.StringArrayInput
	// Name of the GrpcRoute resource.
	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
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules GrpcRouteRuleArrayInput
	// Server-defined URL of this resource.
	SelfLink pulumi.StringPtrInput
	// Time the GrpcRoute was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (GrpcRouteState) ElementType added in v6.56.0 

func (GrpcRouteState) ElementType() reflect.Type

type HttpRoute added in v6.55.0 

type HttpRoute struct {
	pulumi.CustomResourceState

	// Time the HttpRoute was created in UTC.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Gateways defines a list of gateways this HttpRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayOutput `pulumi:"gateways"`
	// Set of hosts that should match against the HTTP host header to select a HttpRoute to process the request.
	Hostnames pulumi.StringArrayOutput `pulumi:"hostnames"`
	// Set of label tags associated with the HttpRoute resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Meshes defines a list of meshes this HttpRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>.
	// The attached Mesh should be of a type SIDECAR.
	Meshes pulumi.StringArrayOutput `pulumi:"meshes"`
	// Name of the HttpRoute resource.
	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"`
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules HttpRouteRuleArrayOutput `pulumi:"rules"`
	// Server-defined URL of this resource.
	SelfLink pulumi.StringOutput `pulumi:"selfLink"`
	// Time the HttpRoute was updated in UTC.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

## Example Usage ### Network Services Http Route 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.NewHttpRoute(ctx, "default", &networkservices.HttpRouteArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.HttpRouteRuleArray{
				&networkservices.HttpRouteRuleArgs{
					Matches: networkservices.HttpRouteRuleMatchArray{
						&networkservices.HttpRouteRuleMatchArgs{
							QueryParameters: networkservices.HttpRouteRuleMatchQueryParameterArray{
								&networkservices.HttpRouteRuleMatchQueryParameterArgs{
									QueryParameter: pulumi.String("key"),
									ExactMatch:     pulumi.String("value"),
								},
							},
							FullPathMatch: pulumi.String("example"),
						},
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Http Route Matches And Actions

```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.NewHttpRoute(ctx, "default", &networkservices.HttpRouteArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.HttpRouteRuleArray{
				&networkservices.HttpRouteRuleArgs{
					Matches: networkservices.HttpRouteRuleMatchArray{
						&networkservices.HttpRouteRuleMatchArgs{
							Headers: networkservices.HttpRouteRuleMatchHeaderArray{
								&networkservices.HttpRouteRuleMatchHeaderArgs{
									Header:      pulumi.String("header"),
									InvertMatch: pulumi.Bool(false),
									RegexMatch:  pulumi.String("header-value"),
								},
							},
							QueryParameters: networkservices.HttpRouteRuleMatchQueryParameterArray{
								&networkservices.HttpRouteRuleMatchQueryParameterArgs{
									QueryParameter: pulumi.String("key"),
									ExactMatch:     pulumi.String("value"),
								},
							},
							PrefixMatch: pulumi.String("example"),
							IgnoreCase:  pulumi.Bool(false),
						},
						&networkservices.HttpRouteRuleMatchArgs{
							Headers: networkservices.HttpRouteRuleMatchHeaderArray{
								&networkservices.HttpRouteRuleMatchHeaderArgs{
									Header:       pulumi.String("header"),
									InvertMatch:  pulumi.Bool(false),
									PresentMatch: pulumi.Bool(true),
								},
							},
							QueryParameters: networkservices.HttpRouteRuleMatchQueryParameterArray{
								&networkservices.HttpRouteRuleMatchQueryParameterArgs{
									QueryParameter: pulumi.String("key"),
									RegexMatch:     pulumi.String("value"),
								},
							},
							RegexMatch: pulumi.String("example"),
							IgnoreCase: pulumi.Bool(false),
						},
						&networkservices.HttpRouteRuleMatchArgs{
							Headers: networkservices.HttpRouteRuleMatchHeaderArray{
								&networkservices.HttpRouteRuleMatchHeaderArgs{
									Header:       pulumi.String("header"),
									InvertMatch:  pulumi.Bool(false),
									PresentMatch: pulumi.Bool(true),
								},
							},
							QueryParameters: networkservices.HttpRouteRuleMatchQueryParameterArray{
								&networkservices.HttpRouteRuleMatchQueryParameterArgs{
									QueryParameter: pulumi.String("key"),
									PresentMatch:   pulumi.Bool(true),
								},
							},
							FullPathMatch: pulumi.String("example"),
							IgnoreCase:    pulumi.Bool(false),
						},
					},
					Action: &networkservices.HttpRouteRuleActionArgs{
						Redirect: &networkservices.HttpRouteRuleActionRedirectArgs{
							HostRedirect:  pulumi.String("new-host"),
							PathRedirect:  pulumi.String("new-path"),
							PrefixRewrite: pulumi.String("new-prefix"),
							HttpsRedirect: pulumi.Bool(true),
							StripQuery:    pulumi.Bool(true),
							PortRedirect:  pulumi.Int(8081),
						},
						UrlRewrite: &networkservices.HttpRouteRuleActionUrlRewriteArgs{
							PathPrefixRewrite: pulumi.String("new-prefix"),
							HostRewrite:       pulumi.String("new-host"),
						},
						RetryPolicy: &networkservices.HttpRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("server_error"),
							},
							NumRetries:    pulumi.Int(1),
							PerTryTimeout: pulumi.String("1s"),
						},
						RequestMirrorPolicy: &networkservices.HttpRouteRuleActionRequestMirrorPolicyArgs{
							Destination: &networkservices.HttpRouteRuleActionRequestMirrorPolicyDestinationArgs{
								ServiceName: pulumi.String("new"),
								Weight:      pulumi.Int(1),
							},
						},
						CorsPolicy: &networkservices.HttpRouteRuleActionCorsPolicyArgs{
							AllowOrigins: pulumi.StringArray{
								pulumi.String("example"),
							},
							AllowMethods: pulumi.StringArray{
								pulumi.String("GET"),
								pulumi.String("PUT"),
							},
							AllowHeaders: pulumi.StringArray{
								pulumi.String("version"),
								pulumi.String("type"),
							},
							ExposeHeaders: pulumi.StringArray{
								pulumi.String("version"),
								pulumi.String("type"),
							},
							MaxAge:           pulumi.String("1s"),
							AllowCredentials: pulumi.Bool(true),
							Disabled:         pulumi.Bool(false),
						},
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Http Route Actions

```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.NewHttpRoute(ctx, "default", &networkservices.HttpRouteArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Rules: networkservices.HttpRouteRuleArray{
				&networkservices.HttpRouteRuleArgs{
					Action: &networkservices.HttpRouteRuleActionArgs{
						FaultInjectionPolicy: &networkservices.HttpRouteRuleActionFaultInjectionPolicyArgs{
							Delay: &networkservices.HttpRouteRuleActionFaultInjectionPolicyDelayArgs{
								FixedDelay: pulumi.String("1s"),
								Percentage: pulumi.Int(1),
							},
							Abort: &networkservices.HttpRouteRuleActionFaultInjectionPolicyAbortArgs{
								HttpStatus: pulumi.Int(500),
								Percentage: pulumi.Int(1),
							},
						},
						UrlRewrite: &networkservices.HttpRouteRuleActionUrlRewriteArgs{
							PathPrefixRewrite: pulumi.String("new-prefix"),
							HostRewrite:       pulumi.String("new-host"),
						},
						RetryPolicy: &networkservices.HttpRouteRuleActionRetryPolicyArgs{
							RetryConditions: pulumi.StringArray{
								pulumi.String("server_error"),
							},
							NumRetries:    pulumi.Int(1),
							PerTryTimeout: pulumi.String("1s"),
						},
						RequestMirrorPolicy: &networkservices.HttpRouteRuleActionRequestMirrorPolicyArgs{
							Destination: &networkservices.HttpRouteRuleActionRequestMirrorPolicyDestinationArgs{
								ServiceName: pulumi.String("new"),
								Weight:      pulumi.Int(1),
							},
						},
						CorsPolicy: &networkservices.HttpRouteRuleActionCorsPolicyArgs{
							AllowOrigins: pulumi.StringArray{
								pulumi.String("example"),
							},
							AllowMethods: pulumi.StringArray{
								pulumi.String("GET"),
								pulumi.String("PUT"),
							},
							AllowHeaders: pulumi.StringArray{
								pulumi.String("version"),
								pulumi.String("type"),
							},
							ExposeHeaders: pulumi.StringArray{
								pulumi.String("version"),
								pulumi.String("type"),
							},
							MaxAge:           pulumi.String("1s"),
							AllowCredentials: pulumi.Bool(true),
							Disabled:         pulumi.Bool(false),
						},
						RequestHeaderModifier: &networkservices.HttpRouteRuleActionRequestHeaderModifierArgs{
							Set: pulumi.StringMap{
								"version": pulumi.String("1"),
								"type":    pulumi.String("json"),
							},
							Add: pulumi.StringMap{
								"minor-version": pulumi.String("1"),
							},
							Removes: pulumi.StringArray{
								pulumi.String("arg"),
							},
						},
						ResponseHeaderModifier: &networkservices.HttpRouteRuleActionResponseHeaderModifierArgs{
							Set: pulumi.StringMap{
								"version": pulumi.String("1"),
								"type":    pulumi.String("json"),
							},
							Add: pulumi.StringMap{
								"minor-version": pulumi.String("1"),
							},
							Removes: pulumi.StringArray{
								pulumi.String("removearg"),
							},
						},
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Http Route Mesh 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 {
		defaultMesh, err := networkservices.NewMesh(ctx, "defaultMesh", &networkservices.MeshArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		_, err = networkservices.NewHttpRoute(ctx, "defaultHttpRoute", &networkservices.HttpRouteArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Hostnames: pulumi.StringArray{
				pulumi.String("example"),
			},
			Meshes: pulumi.StringArray{
				defaultMesh.ID(),
			},
			Rules: networkservices.HttpRouteRuleArray{
				&networkservices.HttpRouteRuleArgs{
					Matches: networkservices.HttpRouteRuleMatchArray{
						&networkservices.HttpRouteRuleMatchArgs{
							QueryParameters: networkservices.HttpRouteRuleMatchQueryParameterArray{
								&networkservices.HttpRouteRuleMatchQueryParameterArgs{
									QueryParameter: pulumi.String("key"),
									ExactMatch:     pulumi.String("value"),
								},
							},
							FullPathMatch: pulumi.String("example"),
						},
					},
				},
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

HttpRoute can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/httpRoute:HttpRoute default projects/{{project}}/locations/global/httpRoutes/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/httpRoute:HttpRoute default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/httpRoute:HttpRoute default {{name}}

```

func GetHttpRoute added in v6.55.0 

func GetHttpRoute(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *HttpRouteState, opts ...pulumi.ResourceOption) (*HttpRoute, error)

GetHttpRoute gets an existing HttpRoute 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 NewHttpRoute added in v6.55.0 

func NewHttpRoute(ctx *pulumi.Context,
	name string, args *HttpRouteArgs, opts ...pulumi.ResourceOption) (*HttpRoute, error)

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

func (*HttpRoute) ElementType added in v6.55.0 

func (*HttpRoute) ElementType() reflect.Type

func (*HttpRoute) ToHttpRouteOutput added in v6.55.0 

func (i *HttpRoute) ToHttpRouteOutput() HttpRouteOutput

func (*HttpRoute) ToHttpRouteOutputWithContext added in v6.55.0 

func (i *HttpRoute) ToHttpRouteOutputWithContext(ctx context.Context) HttpRouteOutput

type HttpRouteArgs added in v6.55.0 

type HttpRouteArgs struct {
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Gateways defines a list of gateways this HttpRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayInput
	// Set of hosts that should match against the HTTP host header to select a HttpRoute to process the request.
	Hostnames pulumi.StringArrayInput
	// Set of label tags associated with the HttpRoute resource.
	Labels pulumi.StringMapInput
	// Meshes defines a list of meshes this HttpRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>.
	// The attached Mesh should be of a type SIDECAR.
	Meshes pulumi.StringArrayInput
	// Name of the HttpRoute resource.
	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
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules HttpRouteRuleArrayInput
}

The set of arguments for constructing a HttpRoute resource.

func (HttpRouteArgs) ElementType added in v6.55.0 

func (HttpRouteArgs) ElementType() reflect.Type

type HttpRouteArray added in v6.55.0 

type HttpRouteArray []HttpRouteInput

func (HttpRouteArray) ElementType added in v6.55.0 

func (HttpRouteArray) ElementType() reflect.Type

func (HttpRouteArray) ToHttpRouteArrayOutput added in v6.55.0 

func (i HttpRouteArray) ToHttpRouteArrayOutput() HttpRouteArrayOutput

func (HttpRouteArray) ToHttpRouteArrayOutputWithContext added in v6.55.0 

func (i HttpRouteArray) ToHttpRouteArrayOutputWithContext(ctx context.Context) HttpRouteArrayOutput

type HttpRouteArrayInput added in v6.55.0 

type HttpRouteArrayInput interface {
	pulumi.Input

	ToHttpRouteArrayOutput() HttpRouteArrayOutput
	ToHttpRouteArrayOutputWithContext(context.Context) HttpRouteArrayOutput
}

HttpRouteArrayInput is an input type that accepts HttpRouteArray and HttpRouteArrayOutput values. You can construct a concrete instance of `HttpRouteArrayInput` via: 

HttpRouteArray{ HttpRouteArgs{...} }

type HttpRouteArrayOutput added in v6.55.0 

type HttpRouteArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteArrayOutput) ElementType added in v6.55.0 

func (HttpRouteArrayOutput) ElementType() reflect.Type

func (HttpRouteArrayOutput) Index added in v6.55.0 

func (o HttpRouteArrayOutput) Index(i pulumi.IntInput) HttpRouteOutput

func (HttpRouteArrayOutput) ToHttpRouteArrayOutput added in v6.55.0 

func (o HttpRouteArrayOutput) ToHttpRouteArrayOutput() HttpRouteArrayOutput

func (HttpRouteArrayOutput) ToHttpRouteArrayOutputWithContext added in v6.55.0 

func (o HttpRouteArrayOutput) ToHttpRouteArrayOutputWithContext(ctx context.Context) HttpRouteArrayOutput

type HttpRouteInput added in v6.55.0 

type HttpRouteInput interface {
	pulumi.Input

	ToHttpRouteOutput() HttpRouteOutput
	ToHttpRouteOutputWithContext(ctx context.Context) HttpRouteOutput
}

type HttpRouteMap added in v6.55.0 

type HttpRouteMap map[string]HttpRouteInput

func (HttpRouteMap) ElementType added in v6.55.0 

func (HttpRouteMap) ElementType() reflect.Type

func (HttpRouteMap) ToHttpRouteMapOutput added in v6.55.0 

func (i HttpRouteMap) ToHttpRouteMapOutput() HttpRouteMapOutput

func (HttpRouteMap) ToHttpRouteMapOutputWithContext added in v6.55.0 

func (i HttpRouteMap) ToHttpRouteMapOutputWithContext(ctx context.Context) HttpRouteMapOutput

type HttpRouteMapInput added in v6.55.0 

type HttpRouteMapInput interface {
	pulumi.Input

	ToHttpRouteMapOutput() HttpRouteMapOutput
	ToHttpRouteMapOutputWithContext(context.Context) HttpRouteMapOutput
}

HttpRouteMapInput is an input type that accepts HttpRouteMap and HttpRouteMapOutput values. You can construct a concrete instance of `HttpRouteMapInput` via: 

HttpRouteMap{ "key": HttpRouteArgs{...} }

type HttpRouteMapOutput added in v6.55.0 

type HttpRouteMapOutput struct{ *pulumi.OutputState }

func (HttpRouteMapOutput) ElementType added in v6.55.0 

func (HttpRouteMapOutput) ElementType() reflect.Type

func (HttpRouteMapOutput) MapIndex added in v6.55.0 

func (o HttpRouteMapOutput) MapIndex(k pulumi.StringInput) HttpRouteOutput

func (HttpRouteMapOutput) ToHttpRouteMapOutput added in v6.55.0 

func (o HttpRouteMapOutput) ToHttpRouteMapOutput() HttpRouteMapOutput

func (HttpRouteMapOutput) ToHttpRouteMapOutputWithContext added in v6.55.0 

func (o HttpRouteMapOutput) ToHttpRouteMapOutputWithContext(ctx context.Context) HttpRouteMapOutput

type HttpRouteOutput added in v6.55.0 

type HttpRouteOutput struct{ *pulumi.OutputState }

func (HttpRouteOutput) CreateTime added in v6.55.0 

func (o HttpRouteOutput) CreateTime() pulumi.StringOutput

Time the HttpRoute was created in UTC.

func (HttpRouteOutput) Description added in v6.55.0 

func (o HttpRouteOutput) Description() pulumi.StringPtrOutput

A free-text description of the resource. Max length 1024 characters.

func (HttpRouteOutput) ElementType added in v6.55.0 

func (HttpRouteOutput) ElementType() reflect.Type

func (HttpRouteOutput) Gateways added in v6.55.0 

func (o HttpRouteOutput) Gateways() pulumi.StringArrayOutput

Gateways defines a list of gateways this HttpRoute is attached to, as one of the routing rules to route the requests served by the gateway. Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>

func (HttpRouteOutput) Hostnames added in v6.55.0 

func (o HttpRouteOutput) Hostnames() pulumi.StringArrayOutput

Set of hosts that should match against the HTTP host header to select a HttpRoute to process the request.

func (HttpRouteOutput) Labels added in v6.55.0 

func (o HttpRouteOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the HttpRoute resource.

func (HttpRouteOutput) Meshes added in v6.55.0 

func (o HttpRouteOutput) Meshes() pulumi.StringArrayOutput

Meshes defines a list of meshes this HttpRoute is attached to, as one of the routing rules to route the requests served by the mesh. Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>. The attached Mesh should be of a type SIDECAR.

func (HttpRouteOutput) Name added in v6.55.0 

func (o HttpRouteOutput) Name() pulumi.StringOutput

Name of the HttpRoute resource.

func (HttpRouteOutput) Project added in v6.55.0 

func (o HttpRouteOutput) Project() pulumi.StringOutput

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

func (HttpRouteOutput) Rules added in v6.55.0 

func (o HttpRouteOutput) Rules() HttpRouteRuleArrayOutput

Rules that define how traffic is routed and handled. Structure is documented below. 

func (o HttpRouteOutput) SelfLink() pulumi.StringOutput

Server-defined URL of this resource.

func (HttpRouteOutput) ToHttpRouteOutput added in v6.55.0 

func (o HttpRouteOutput) ToHttpRouteOutput() HttpRouteOutput

func (HttpRouteOutput) ToHttpRouteOutputWithContext added in v6.55.0 

func (o HttpRouteOutput) ToHttpRouteOutputWithContext(ctx context.Context) HttpRouteOutput

func (HttpRouteOutput) UpdateTime added in v6.55.0 

func (o HttpRouteOutput) UpdateTime() pulumi.StringOutput

Time the HttpRoute was updated in UTC.

type HttpRouteRule added in v6.55.0 

type HttpRouteRule struct {
	// The detailed rule defining how to route matched traffic.
	// Structure is documented below.
	Action *HttpRouteRuleAction `pulumi:"action"`
	// A list of matches define conditions used for matching the rule against incoming HTTP requests. Each match is independent, i.e. this rule will be matched if ANY one of the matches is satisfied.
	// If no matches field is specified, this rule will unconditionally match traffic.
	// If a default rule is desired to be configured, add a rule with no matches specified to the end of the rules list.
	// Structure is documented below.
	Matches []HttpRouteRuleMatch `pulumi:"matches"`
}

type HttpRouteRuleAction added in v6.55.0 

type HttpRouteRuleAction struct {
	// The specification for allowing client side cross-origin requests.
	// Structure is documented below.
	CorsPolicy *HttpRouteRuleActionCorsPolicy `pulumi:"corsPolicy"`
	// The destination to which traffic should be forwarded.
	// Structure is documented below.
	Destinations []HttpRouteRuleActionDestination `pulumi:"destinations"`
	// The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
	// Structure is documented below.
	FaultInjectionPolicy *HttpRouteRuleActionFaultInjectionPolicy `pulumi:"faultInjectionPolicy"`
	// If set, the request is directed as configured by this field.
	// Structure is documented below.
	Redirect *HttpRouteRuleActionRedirect `pulumi:"redirect"`
	// The specification for modifying the headers of a matching request prior to delivery of the request to the destination.
	// Structure is documented below.
	RequestHeaderModifier *HttpRouteRuleActionRequestHeaderModifier `pulumi:"requestHeaderModifier"`
	// Specifies the policy on how requests intended for the routes destination are shadowed to a separate mirrored destination.
	// Structure is documented below.
	RequestMirrorPolicy *HttpRouteRuleActionRequestMirrorPolicy `pulumi:"requestMirrorPolicy"`
	// The specification for modifying the headers of a response prior to sending the response back to the client.
	// Structure is documented below.
	ResponseHeaderModifier *HttpRouteRuleActionResponseHeaderModifier `pulumi:"responseHeaderModifier"`
	// Specifies the retry policy associated with this route.
	// Structure is documented below.
	RetryPolicy *HttpRouteRuleActionRetryPolicy `pulumi:"retryPolicy"`
	// Specifies the timeout for selected route.
	Timeout *string `pulumi:"timeout"`
	// The specification for rewrite URL before forwarding requests to the destination.
	// Structure is documented below.
	UrlRewrite *HttpRouteRuleActionUrlRewrite `pulumi:"urlRewrite"`
}

type HttpRouteRuleActionArgs added in v6.55.0 

type HttpRouteRuleActionArgs struct {
	// The specification for allowing client side cross-origin requests.
	// Structure is documented below.
	CorsPolicy HttpRouteRuleActionCorsPolicyPtrInput `pulumi:"corsPolicy"`
	// The destination to which traffic should be forwarded.
	// Structure is documented below.
	Destinations HttpRouteRuleActionDestinationArrayInput `pulumi:"destinations"`
	// The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure.
	// Structure is documented below.
	FaultInjectionPolicy HttpRouteRuleActionFaultInjectionPolicyPtrInput `pulumi:"faultInjectionPolicy"`
	// If set, the request is directed as configured by this field.
	// Structure is documented below.
	Redirect HttpRouteRuleActionRedirectPtrInput `pulumi:"redirect"`
	// The specification for modifying the headers of a matching request prior to delivery of the request to the destination.
	// Structure is documented below.
	RequestHeaderModifier HttpRouteRuleActionRequestHeaderModifierPtrInput `pulumi:"requestHeaderModifier"`
	// Specifies the policy on how requests intended for the routes destination are shadowed to a separate mirrored destination.
	// Structure is documented below.
	RequestMirrorPolicy HttpRouteRuleActionRequestMirrorPolicyPtrInput `pulumi:"requestMirrorPolicy"`
	// The specification for modifying the headers of a response prior to sending the response back to the client.
	// Structure is documented below.
	ResponseHeaderModifier HttpRouteRuleActionResponseHeaderModifierPtrInput `pulumi:"responseHeaderModifier"`
	// Specifies the retry policy associated with this route.
	// Structure is documented below.
	RetryPolicy HttpRouteRuleActionRetryPolicyPtrInput `pulumi:"retryPolicy"`
	// Specifies the timeout for selected route.
	Timeout pulumi.StringPtrInput `pulumi:"timeout"`
	// The specification for rewrite URL before forwarding requests to the destination.
	// Structure is documented below.
	UrlRewrite HttpRouteRuleActionUrlRewritePtrInput `pulumi:"urlRewrite"`
}

func (HttpRouteRuleActionArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionArgs) ElementType() reflect.Type

func (HttpRouteRuleActionArgs) ToHttpRouteRuleActionOutput added in v6.55.0 

func (i HttpRouteRuleActionArgs) ToHttpRouteRuleActionOutput() HttpRouteRuleActionOutput

func (HttpRouteRuleActionArgs) ToHttpRouteRuleActionOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionArgs) ToHttpRouteRuleActionOutputWithContext(ctx context.Context) HttpRouteRuleActionOutput

func (HttpRouteRuleActionArgs) ToHttpRouteRuleActionPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionArgs) ToHttpRouteRuleActionPtrOutput() HttpRouteRuleActionPtrOutput

func (HttpRouteRuleActionArgs) ToHttpRouteRuleActionPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionArgs) ToHttpRouteRuleActionPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionPtrOutput

type HttpRouteRuleActionCorsPolicy added in v6.55.0 

type HttpRouteRuleActionCorsPolicy struct {
	// In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
	AllowCredentials *bool `pulumi:"allowCredentials"`
	// Specifies the content for Access-Control-Allow-Headers header.
	AllowHeaders []string `pulumi:"allowHeaders"`
	// Specifies the content for Access-Control-Allow-Methods header.
	AllowMethods []string `pulumi:"allowMethods"`
	// Specifies the regular expression patterns that match allowed origins.
	AllowOriginRegexes []string `pulumi:"allowOriginRegexes"`
	// Specifies the list of origins that will be allowed to do CORS requests.
	AllowOrigins []string `pulumi:"allowOrigins"`
	// If true, 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 Access-Control-Expose-Headers header.
	ExposeHeaders []string `pulumi:"exposeHeaders"`
	// Specifies how long result of a preflight request can be cached in seconds.
	MaxAge *string `pulumi:"maxAge"`
}

type HttpRouteRuleActionCorsPolicyArgs added in v6.55.0 

type HttpRouteRuleActionCorsPolicyArgs struct {
	// In response to a preflight request, setting this to true indicates that the actual request can include user credentials.
	AllowCredentials pulumi.BoolPtrInput `pulumi:"allowCredentials"`
	// Specifies the content for Access-Control-Allow-Headers header.
	AllowHeaders pulumi.StringArrayInput `pulumi:"allowHeaders"`
	// Specifies the content for Access-Control-Allow-Methods header.
	AllowMethods pulumi.StringArrayInput `pulumi:"allowMethods"`
	// Specifies the regular expression patterns that match allowed origins.
	AllowOriginRegexes pulumi.StringArrayInput `pulumi:"allowOriginRegexes"`
	// Specifies the list of origins that will be allowed to do CORS requests.
	AllowOrigins pulumi.StringArrayInput `pulumi:"allowOrigins"`
	// If true, 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 Access-Control-Expose-Headers header.
	ExposeHeaders pulumi.StringArrayInput `pulumi:"exposeHeaders"`
	// Specifies how long result of a preflight request can be cached in seconds.
	MaxAge pulumi.StringPtrInput `pulumi:"maxAge"`
}

func (HttpRouteRuleActionCorsPolicyArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionCorsPolicyArgs) ElementType() reflect.Type

func (HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyOutput added in v6.55.0 

func (i HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyOutput() HttpRouteRuleActionCorsPolicyOutput

func (HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyOutputWithContext(ctx context.Context) HttpRouteRuleActionCorsPolicyOutput

func (HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyPtrOutput() HttpRouteRuleActionCorsPolicyPtrOutput

func (HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionCorsPolicyArgs) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionCorsPolicyPtrOutput

type HttpRouteRuleActionCorsPolicyInput added in v6.55.0 

type HttpRouteRuleActionCorsPolicyInput interface {
	pulumi.Input

	ToHttpRouteRuleActionCorsPolicyOutput() HttpRouteRuleActionCorsPolicyOutput
	ToHttpRouteRuleActionCorsPolicyOutputWithContext(context.Context) HttpRouteRuleActionCorsPolicyOutput
}

HttpRouteRuleActionCorsPolicyInput is an input type that accepts HttpRouteRuleActionCorsPolicyArgs and HttpRouteRuleActionCorsPolicyOutput values. You can construct a concrete instance of `HttpRouteRuleActionCorsPolicyInput` via: 

HttpRouteRuleActionCorsPolicyArgs{...}

type HttpRouteRuleActionCorsPolicyOutput added in v6.55.0 

type HttpRouteRuleActionCorsPolicyOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionCorsPolicyOutput) AllowCredentials added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowCredentials() pulumi.BoolPtrOutput

In response to a preflight request, setting this to true indicates that the actual request can include user credentials.

func (HttpRouteRuleActionCorsPolicyOutput) AllowHeaders added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowHeaders() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyOutput) AllowMethods added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowMethods() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyOutput) AllowOriginRegexes added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowOriginRegexes() pulumi.StringArrayOutput

Specifies the regular expression patterns that match allowed origins.

func (HttpRouteRuleActionCorsPolicyOutput) AllowOrigins added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) AllowOrigins() pulumi.StringArrayOutput

Specifies the list of origins that will be allowed to do CORS requests.

func (HttpRouteRuleActionCorsPolicyOutput) Disabled added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) Disabled() pulumi.BoolPtrOutput

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

***

func (HttpRouteRuleActionCorsPolicyOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionCorsPolicyOutput) ElementType() reflect.Type

func (HttpRouteRuleActionCorsPolicyOutput) ExposeHeaders added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) ExposeHeaders() pulumi.StringArrayOutput

Specifies the content for Access-Control-Expose-Headers header.

func (HttpRouteRuleActionCorsPolicyOutput) MaxAge added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) MaxAge() pulumi.StringPtrOutput

Specifies how long result of a preflight request can be cached in seconds.

func (HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyOutput added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyOutput() HttpRouteRuleActionCorsPolicyOutput

func (HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyOutputWithContext(ctx context.Context) HttpRouteRuleActionCorsPolicyOutput

func (HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyPtrOutput() HttpRouteRuleActionCorsPolicyPtrOutput

func (HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyOutput) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionCorsPolicyPtrOutput

type HttpRouteRuleActionCorsPolicyPtrInput added in v6.55.0 

type HttpRouteRuleActionCorsPolicyPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionCorsPolicyPtrOutput() HttpRouteRuleActionCorsPolicyPtrOutput
	ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext(context.Context) HttpRouteRuleActionCorsPolicyPtrOutput
}

HttpRouteRuleActionCorsPolicyPtrInput is an input type that accepts HttpRouteRuleActionCorsPolicyArgs, HttpRouteRuleActionCorsPolicyPtr and HttpRouteRuleActionCorsPolicyPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionCorsPolicyPtrInput` via: 

        HttpRouteRuleActionCorsPolicyArgs{...}

or:

        nil

func HttpRouteRuleActionCorsPolicyPtr added in v6.55.0 

func HttpRouteRuleActionCorsPolicyPtr(v *HttpRouteRuleActionCorsPolicyArgs) HttpRouteRuleActionCorsPolicyPtrInput

type HttpRouteRuleActionCorsPolicyPtrOutput added in v6.55.0 

type HttpRouteRuleActionCorsPolicyPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowCredentials added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowCredentials() pulumi.BoolPtrOutput

In response to a preflight request, setting this to true indicates that the actual request can include user credentials.

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowHeaders added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowHeaders() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowMethods added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowMethods() pulumi.StringArrayOutput

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

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowOriginRegexes added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowOriginRegexes() pulumi.StringArrayOutput

Specifies the regular expression patterns that match allowed origins.

func (HttpRouteRuleActionCorsPolicyPtrOutput) AllowOrigins added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) AllowOrigins() pulumi.StringArrayOutput

Specifies the list of origins that will be allowed to do CORS requests.

func (HttpRouteRuleActionCorsPolicyPtrOutput) Disabled added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) Disabled() pulumi.BoolPtrOutput

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

***

func (HttpRouteRuleActionCorsPolicyPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) Elem() HttpRouteRuleActionCorsPolicyOutput

func (HttpRouteRuleActionCorsPolicyPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionCorsPolicyPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionCorsPolicyPtrOutput) ExposeHeaders added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) ExposeHeaders() pulumi.StringArrayOutput

Specifies the content for Access-Control-Expose-Headers header.

func (HttpRouteRuleActionCorsPolicyPtrOutput) MaxAge added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) MaxAge() pulumi.StringPtrOutput

Specifies how long result of a preflight request can be cached in seconds.

func (HttpRouteRuleActionCorsPolicyPtrOutput) ToHttpRouteRuleActionCorsPolicyPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) ToHttpRouteRuleActionCorsPolicyPtrOutput() HttpRouteRuleActionCorsPolicyPtrOutput

func (HttpRouteRuleActionCorsPolicyPtrOutput) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionCorsPolicyPtrOutput) ToHttpRouteRuleActionCorsPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionCorsPolicyPtrOutput

type HttpRouteRuleActionDestination added in v6.55.0 

type HttpRouteRuleActionDestination struct {
	// The URL of a BackendService to route traffic to.
	ServiceName *string `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
	// If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
	// If weights are specified for any one service name, they need to be specified for all of them.
	// If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
	Weight *int `pulumi:"weight"`
}

type HttpRouteRuleActionDestinationArgs added in v6.55.0 

type HttpRouteRuleActionDestinationArgs struct {
	// The URL of a BackendService to route traffic to.
	ServiceName pulumi.StringPtrInput `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
	// If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
	// If weights are specified for any one service name, they need to be specified for all of them.
	// If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

func (HttpRouteRuleActionDestinationArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionDestinationArgs) ElementType() reflect.Type

func (HttpRouteRuleActionDestinationArgs) ToHttpRouteRuleActionDestinationOutput added in v6.55.0 

func (i HttpRouteRuleActionDestinationArgs) ToHttpRouteRuleActionDestinationOutput() HttpRouteRuleActionDestinationOutput

func (HttpRouteRuleActionDestinationArgs) ToHttpRouteRuleActionDestinationOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionDestinationArgs) ToHttpRouteRuleActionDestinationOutputWithContext(ctx context.Context) HttpRouteRuleActionDestinationOutput

type HttpRouteRuleActionDestinationArray added in v6.55.0 

type HttpRouteRuleActionDestinationArray []HttpRouteRuleActionDestinationInput

func (HttpRouteRuleActionDestinationArray) ElementType added in v6.55.0 

func (HttpRouteRuleActionDestinationArray) ElementType() reflect.Type

func (HttpRouteRuleActionDestinationArray) ToHttpRouteRuleActionDestinationArrayOutput added in v6.55.0 

func (i HttpRouteRuleActionDestinationArray) ToHttpRouteRuleActionDestinationArrayOutput() HttpRouteRuleActionDestinationArrayOutput

func (HttpRouteRuleActionDestinationArray) ToHttpRouteRuleActionDestinationArrayOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionDestinationArray) ToHttpRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) HttpRouteRuleActionDestinationArrayOutput

type HttpRouteRuleActionDestinationArrayInput added in v6.55.0 

type HttpRouteRuleActionDestinationArrayInput interface {
	pulumi.Input

	ToHttpRouteRuleActionDestinationArrayOutput() HttpRouteRuleActionDestinationArrayOutput
	ToHttpRouteRuleActionDestinationArrayOutputWithContext(context.Context) HttpRouteRuleActionDestinationArrayOutput
}

HttpRouteRuleActionDestinationArrayInput is an input type that accepts HttpRouteRuleActionDestinationArray and HttpRouteRuleActionDestinationArrayOutput values. You can construct a concrete instance of `HttpRouteRuleActionDestinationArrayInput` via: 

HttpRouteRuleActionDestinationArray{ HttpRouteRuleActionDestinationArgs{...} }

type HttpRouteRuleActionDestinationArrayOutput added in v6.55.0 

type HttpRouteRuleActionDestinationArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionDestinationArrayOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionDestinationArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleActionDestinationArrayOutput) Index added in v6.55.0 

func (o HttpRouteRuleActionDestinationArrayOutput) Index(i pulumi.IntInput) HttpRouteRuleActionDestinationOutput

func (HttpRouteRuleActionDestinationArrayOutput) ToHttpRouteRuleActionDestinationArrayOutput added in v6.55.0 

func (o HttpRouteRuleActionDestinationArrayOutput) ToHttpRouteRuleActionDestinationArrayOutput() HttpRouteRuleActionDestinationArrayOutput

func (HttpRouteRuleActionDestinationArrayOutput) ToHttpRouteRuleActionDestinationArrayOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionDestinationArrayOutput) ToHttpRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) HttpRouteRuleActionDestinationArrayOutput

type HttpRouteRuleActionDestinationInput added in v6.55.0 

type HttpRouteRuleActionDestinationInput interface {
	pulumi.Input

	ToHttpRouteRuleActionDestinationOutput() HttpRouteRuleActionDestinationOutput
	ToHttpRouteRuleActionDestinationOutputWithContext(context.Context) HttpRouteRuleActionDestinationOutput
}

HttpRouteRuleActionDestinationInput is an input type that accepts HttpRouteRuleActionDestinationArgs and HttpRouteRuleActionDestinationOutput values. You can construct a concrete instance of `HttpRouteRuleActionDestinationInput` via: 

HttpRouteRuleActionDestinationArgs{...}

type HttpRouteRuleActionDestinationOutput added in v6.55.0 

type HttpRouteRuleActionDestinationOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionDestinationOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionDestinationOutput) ElementType() reflect.Type

func (HttpRouteRuleActionDestinationOutput) ServiceName added in v6.55.0 

func (o HttpRouteRuleActionDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (HttpRouteRuleActionDestinationOutput) ToHttpRouteRuleActionDestinationOutput added in v6.55.0 

func (o HttpRouteRuleActionDestinationOutput) ToHttpRouteRuleActionDestinationOutput() HttpRouteRuleActionDestinationOutput

func (HttpRouteRuleActionDestinationOutput) ToHttpRouteRuleActionDestinationOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionDestinationOutput) ToHttpRouteRuleActionDestinationOutputWithContext(ctx context.Context) HttpRouteRuleActionDestinationOutput

func (HttpRouteRuleActionDestinationOutput) Weight added in v6.55.0 

func (o HttpRouteRuleActionDestinationOutput) Weight() pulumi.IntPtrOutput

Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports. If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend. If weights are specified for any one service name, they need to be specified for all of them. If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.

type HttpRouteRuleActionFaultInjectionPolicy added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicy struct {
	// Specification of how client requests are aborted as part of fault injection before being sent to a destination.
	// Structure is documented below.
	Abort *HttpRouteRuleActionFaultInjectionPolicyAbort `pulumi:"abort"`
	// Specification of how client requests are delayed as part of fault injection before being sent to a destination.
	// Structure is documented below.
	Delay *HttpRouteRuleActionFaultInjectionPolicyDelay `pulumi:"delay"`
}

type HttpRouteRuleActionFaultInjectionPolicyAbort added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyAbort struct {
	// The HTTP status code used to abort the request.
	HttpStatus *int `pulumi:"httpStatus"`
	// The percentage of traffic which will be aborted.
	Percentage *int `pulumi:"percentage"`
}

type HttpRouteRuleActionFaultInjectionPolicyAbortArgs added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyAbortArgs struct {
	// The HTTP status code used to abort the request.
	HttpStatus pulumi.IntPtrInput `pulumi:"httpStatus"`
	// The percentage of traffic which will be aborted.
	Percentage pulumi.IntPtrInput `pulumi:"percentage"`
}

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput() HttpRouteRuleActionFaultInjectionPolicyAbortOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyAbortOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyAbortArgs) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

type HttpRouteRuleActionFaultInjectionPolicyAbortInput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyAbortInput interface {
	pulumi.Input

	ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput() HttpRouteRuleActionFaultInjectionPolicyAbortOutput
	ToHttpRouteRuleActionFaultInjectionPolicyAbortOutputWithContext(context.Context) HttpRouteRuleActionFaultInjectionPolicyAbortOutput
}

HttpRouteRuleActionFaultInjectionPolicyAbortInput is an input type that accepts HttpRouteRuleActionFaultInjectionPolicyAbortArgs and HttpRouteRuleActionFaultInjectionPolicyAbortOutput values. You can construct a concrete instance of `HttpRouteRuleActionFaultInjectionPolicyAbortInput` via: 

HttpRouteRuleActionFaultInjectionPolicyAbortArgs{...}

type HttpRouteRuleActionFaultInjectionPolicyAbortOutput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyAbortOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) HttpStatus added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) HttpStatus() pulumi.IntPtrOutput

The HTTP status code used to abort the request.

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) Percentage added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic which will be aborted.

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutput() HttpRouteRuleActionFaultInjectionPolicyAbortOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyAbortOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

type HttpRouteRuleActionFaultInjectionPolicyAbortPtrInput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyAbortPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput
	ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext(context.Context) HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput
}

HttpRouteRuleActionFaultInjectionPolicyAbortPtrInput is an input type that accepts HttpRouteRuleActionFaultInjectionPolicyAbortArgs, HttpRouteRuleActionFaultInjectionPolicyAbortPtr and HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionFaultInjectionPolicyAbortPtrInput` via: 

        HttpRouteRuleActionFaultInjectionPolicyAbortArgs{...}

or:

        nil

func HttpRouteRuleActionFaultInjectionPolicyAbortPtr added in v6.55.0 

func HttpRouteRuleActionFaultInjectionPolicyAbortPtr(v *HttpRouteRuleActionFaultInjectionPolicyAbortArgs) HttpRouteRuleActionFaultInjectionPolicyAbortPtrInput

type HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Elem() HttpRouteRuleActionFaultInjectionPolicyAbortOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) HttpStatus added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) HttpStatus() pulumi.IntPtrOutput

The HTTP status code used to abort the request.

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Percentage added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic which will be aborted.

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyAbortPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

type HttpRouteRuleActionFaultInjectionPolicyArgs added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyArgs struct {
	// Specification of how client requests are aborted as part of fault injection before being sent to a destination.
	// Structure is documented below.
	Abort HttpRouteRuleActionFaultInjectionPolicyAbortPtrInput `pulumi:"abort"`
	// Specification of how client requests are delayed as part of fault injection before being sent to a destination.
	// Structure is documented below.
	Delay HttpRouteRuleActionFaultInjectionPolicyDelayPtrInput `pulumi:"delay"`
}

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyOutput added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyOutput() HttpRouteRuleActionFaultInjectionPolicyOutput

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyOutput

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput() HttpRouteRuleActionFaultInjectionPolicyPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyArgs) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyPtrOutput

type HttpRouteRuleActionFaultInjectionPolicyDelay added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyDelay struct {
	// Specify a fixed delay before forwarding the request.
	FixedDelay *string `pulumi:"fixedDelay"`
	// The percentage of traffic on which delay will be injected.
	Percentage *int `pulumi:"percentage"`
}

type HttpRouteRuleActionFaultInjectionPolicyDelayArgs added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyDelayArgs struct {
	// Specify a fixed delay before forwarding the request.
	FixedDelay pulumi.StringPtrInput `pulumi:"fixedDelay"`
	// The percentage of traffic on which delay will be injected.
	Percentage pulumi.IntPtrInput `pulumi:"percentage"`
}

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput() HttpRouteRuleActionFaultInjectionPolicyDelayOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyDelayOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionFaultInjectionPolicyDelayArgs) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

type HttpRouteRuleActionFaultInjectionPolicyDelayInput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyDelayInput interface {
	pulumi.Input

	ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput() HttpRouteRuleActionFaultInjectionPolicyDelayOutput
	ToHttpRouteRuleActionFaultInjectionPolicyDelayOutputWithContext(context.Context) HttpRouteRuleActionFaultInjectionPolicyDelayOutput
}

HttpRouteRuleActionFaultInjectionPolicyDelayInput is an input type that accepts HttpRouteRuleActionFaultInjectionPolicyDelayArgs and HttpRouteRuleActionFaultInjectionPolicyDelayOutput values. You can construct a concrete instance of `HttpRouteRuleActionFaultInjectionPolicyDelayInput` via: 

HttpRouteRuleActionFaultInjectionPolicyDelayArgs{...}

type HttpRouteRuleActionFaultInjectionPolicyDelayOutput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyDelayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) FixedDelay added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) FixedDelay() pulumi.StringPtrOutput

Specify a fixed delay before forwarding the request.

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) Percentage added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic on which delay will be injected.

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutput() HttpRouteRuleActionFaultInjectionPolicyDelayOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyDelayOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

type HttpRouteRuleActionFaultInjectionPolicyDelayPtrInput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyDelayPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput
	ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext(context.Context) HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput
}

HttpRouteRuleActionFaultInjectionPolicyDelayPtrInput is an input type that accepts HttpRouteRuleActionFaultInjectionPolicyDelayArgs, HttpRouteRuleActionFaultInjectionPolicyDelayPtr and HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionFaultInjectionPolicyDelayPtrInput` via: 

        HttpRouteRuleActionFaultInjectionPolicyDelayArgs{...}

or:

        nil

func HttpRouteRuleActionFaultInjectionPolicyDelayPtr added in v6.55.0 

func HttpRouteRuleActionFaultInjectionPolicyDelayPtr(v *HttpRouteRuleActionFaultInjectionPolicyDelayArgs) HttpRouteRuleActionFaultInjectionPolicyDelayPtrInput

type HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Elem() HttpRouteRuleActionFaultInjectionPolicyDelayOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) FixedDelay added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) FixedDelay() pulumi.StringPtrOutput

Specify a fixed delay before forwarding the request.

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Percentage added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) Percentage() pulumi.IntPtrOutput

The percentage of traffic on which delay will be injected.

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyDelayPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

type HttpRouteRuleActionFaultInjectionPolicyInput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyInput interface {
	pulumi.Input

	ToHttpRouteRuleActionFaultInjectionPolicyOutput() HttpRouteRuleActionFaultInjectionPolicyOutput
	ToHttpRouteRuleActionFaultInjectionPolicyOutputWithContext(context.Context) HttpRouteRuleActionFaultInjectionPolicyOutput
}

HttpRouteRuleActionFaultInjectionPolicyInput is an input type that accepts HttpRouteRuleActionFaultInjectionPolicyArgs and HttpRouteRuleActionFaultInjectionPolicyOutput values. You can construct a concrete instance of `HttpRouteRuleActionFaultInjectionPolicyInput` via: 

HttpRouteRuleActionFaultInjectionPolicyArgs{...}

type HttpRouteRuleActionFaultInjectionPolicyOutput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyOutput) Abort added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyOutput) Abort() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

Specification of how client requests are aborted as part of fault injection before being sent to a destination. Structure is documented below.

func (HttpRouteRuleActionFaultInjectionPolicyOutput) Delay added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyOutput) Delay() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

Specification of how client requests are delayed as part of fault injection before being sent to a destination. Structure is documented below.

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyOutput() HttpRouteRuleActionFaultInjectionPolicyOutput

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyOutput

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput() HttpRouteRuleActionFaultInjectionPolicyPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyPtrOutput

type HttpRouteRuleActionFaultInjectionPolicyPtrInput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput() HttpRouteRuleActionFaultInjectionPolicyPtrOutput
	ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext(context.Context) HttpRouteRuleActionFaultInjectionPolicyPtrOutput
}

HttpRouteRuleActionFaultInjectionPolicyPtrInput is an input type that accepts HttpRouteRuleActionFaultInjectionPolicyArgs, HttpRouteRuleActionFaultInjectionPolicyPtr and HttpRouteRuleActionFaultInjectionPolicyPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionFaultInjectionPolicyPtrInput` via: 

        HttpRouteRuleActionFaultInjectionPolicyArgs{...}

or:

        nil

func HttpRouteRuleActionFaultInjectionPolicyPtr added in v6.55.0 

func HttpRouteRuleActionFaultInjectionPolicyPtr(v *HttpRouteRuleActionFaultInjectionPolicyArgs) HttpRouteRuleActionFaultInjectionPolicyPtrInput

type HttpRouteRuleActionFaultInjectionPolicyPtrOutput added in v6.55.0 

type HttpRouteRuleActionFaultInjectionPolicyPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) Abort added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyPtrOutput) Abort() HttpRouteRuleActionFaultInjectionPolicyAbortPtrOutput

Specification of how client requests are aborted as part of fault injection before being sent to a destination. Structure is documented below.

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) Delay added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyPtrOutput) Delay() HttpRouteRuleActionFaultInjectionPolicyDelayPtrOutput

Specification of how client requests are delayed as part of fault injection before being sent to a destination. Structure is documented below.

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyPtrOutput) Elem() HttpRouteRuleActionFaultInjectionPolicyOutput

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutput() HttpRouteRuleActionFaultInjectionPolicyPtrOutput

func (HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionFaultInjectionPolicyPtrOutput) ToHttpRouteRuleActionFaultInjectionPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionFaultInjectionPolicyPtrOutput

type HttpRouteRuleActionInput added in v6.55.0 

type HttpRouteRuleActionInput interface {
	pulumi.Input

	ToHttpRouteRuleActionOutput() HttpRouteRuleActionOutput
	ToHttpRouteRuleActionOutputWithContext(context.Context) HttpRouteRuleActionOutput
}

HttpRouteRuleActionInput is an input type that accepts HttpRouteRuleActionArgs and HttpRouteRuleActionOutput values. You can construct a concrete instance of `HttpRouteRuleActionInput` via: 

HttpRouteRuleActionArgs{...}

type HttpRouteRuleActionOutput added in v6.55.0 

type HttpRouteRuleActionOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionOutput) CorsPolicy added in v6.55.0 

func (o HttpRouteRuleActionOutput) CorsPolicy() HttpRouteRuleActionCorsPolicyPtrOutput

The specification for allowing client side cross-origin requests. Structure is documented below.

func (HttpRouteRuleActionOutput) Destinations added in v6.55.0 

func (o HttpRouteRuleActionOutput) Destinations() HttpRouteRuleActionDestinationArrayOutput

The destination to which traffic should be forwarded. Structure is documented below.

func (HttpRouteRuleActionOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionOutput) ElementType() reflect.Type

func (HttpRouteRuleActionOutput) FaultInjectionPolicy added in v6.55.0 

func (o HttpRouteRuleActionOutput) FaultInjectionPolicy() HttpRouteRuleActionFaultInjectionPolicyPtrOutput

The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure. Structure is documented below.

func (HttpRouteRuleActionOutput) Redirect added in v6.55.0 

func (o HttpRouteRuleActionOutput) Redirect() HttpRouteRuleActionRedirectPtrOutput

If set, the request is directed as configured by this field. Structure is documented below.

func (HttpRouteRuleActionOutput) RequestHeaderModifier added in v6.55.0 

func (o HttpRouteRuleActionOutput) RequestHeaderModifier() HttpRouteRuleActionRequestHeaderModifierPtrOutput

The specification for modifying the headers of a matching request prior to delivery of the request to the destination. Structure is documented below.

func (HttpRouteRuleActionOutput) RequestMirrorPolicy added in v6.55.0 

func (o HttpRouteRuleActionOutput) RequestMirrorPolicy() HttpRouteRuleActionRequestMirrorPolicyPtrOutput

Specifies the policy on how requests intended for the routes destination are shadowed to a separate mirrored destination. Structure is documented below.

func (HttpRouteRuleActionOutput) ResponseHeaderModifier added in v6.55.0 

func (o HttpRouteRuleActionOutput) ResponseHeaderModifier() HttpRouteRuleActionResponseHeaderModifierPtrOutput

The specification for modifying the headers of a response prior to sending the response back to the client. Structure is documented below.

func (HttpRouteRuleActionOutput) RetryPolicy added in v6.55.0 

func (o HttpRouteRuleActionOutput) RetryPolicy() HttpRouteRuleActionRetryPolicyPtrOutput

Specifies the retry policy associated with this route. Structure is documented below.

func (HttpRouteRuleActionOutput) Timeout added in v6.55.0 

func (o HttpRouteRuleActionOutput) Timeout() pulumi.StringPtrOutput

Specifies the timeout for selected route.

func (HttpRouteRuleActionOutput) ToHttpRouteRuleActionOutput added in v6.55.0 

func (o HttpRouteRuleActionOutput) ToHttpRouteRuleActionOutput() HttpRouteRuleActionOutput

func (HttpRouteRuleActionOutput) ToHttpRouteRuleActionOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionOutput) ToHttpRouteRuleActionOutputWithContext(ctx context.Context) HttpRouteRuleActionOutput

func (HttpRouteRuleActionOutput) ToHttpRouteRuleActionPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionOutput) ToHttpRouteRuleActionPtrOutput() HttpRouteRuleActionPtrOutput

func (HttpRouteRuleActionOutput) ToHttpRouteRuleActionPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionOutput) ToHttpRouteRuleActionPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionPtrOutput

func (HttpRouteRuleActionOutput) UrlRewrite added in v6.55.0 

func (o HttpRouteRuleActionOutput) UrlRewrite() HttpRouteRuleActionUrlRewritePtrOutput

The specification for rewrite URL before forwarding requests to the destination. Structure is documented below.

type HttpRouteRuleActionPtrInput added in v6.55.0 

type HttpRouteRuleActionPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionPtrOutput() HttpRouteRuleActionPtrOutput
	ToHttpRouteRuleActionPtrOutputWithContext(context.Context) HttpRouteRuleActionPtrOutput
}

HttpRouteRuleActionPtrInput is an input type that accepts HttpRouteRuleActionArgs, HttpRouteRuleActionPtr and HttpRouteRuleActionPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionPtrInput` via: 

        HttpRouteRuleActionArgs{...}

or:

        nil

func HttpRouteRuleActionPtr added in v6.55.0 

func HttpRouteRuleActionPtr(v *HttpRouteRuleActionArgs) HttpRouteRuleActionPtrInput

type HttpRouteRuleActionPtrOutput added in v6.55.0 

type HttpRouteRuleActionPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionPtrOutput) CorsPolicy added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) CorsPolicy() HttpRouteRuleActionCorsPolicyPtrOutput

The specification for allowing client side cross-origin requests. Structure is documented below.

func (HttpRouteRuleActionPtrOutput) Destinations added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) Destinations() HttpRouteRuleActionDestinationArrayOutput

The destination to which traffic should be forwarded. Structure is documented below.

func (HttpRouteRuleActionPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) Elem() HttpRouteRuleActionOutput

func (HttpRouteRuleActionPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionPtrOutput) FaultInjectionPolicy added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) FaultInjectionPolicy() HttpRouteRuleActionFaultInjectionPolicyPtrOutput

The specification for fault injection introduced into traffic to test the resiliency of clients to backend service failure. Structure is documented below.

func (HttpRouteRuleActionPtrOutput) Redirect added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) Redirect() HttpRouteRuleActionRedirectPtrOutput

If set, the request is directed as configured by this field. Structure is documented below.

func (HttpRouteRuleActionPtrOutput) RequestHeaderModifier added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) RequestHeaderModifier() HttpRouteRuleActionRequestHeaderModifierPtrOutput

The specification for modifying the headers of a matching request prior to delivery of the request to the destination. Structure is documented below.

func (HttpRouteRuleActionPtrOutput) RequestMirrorPolicy added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) RequestMirrorPolicy() HttpRouteRuleActionRequestMirrorPolicyPtrOutput

Specifies the policy on how requests intended for the routes destination are shadowed to a separate mirrored destination. Structure is documented below.

func (HttpRouteRuleActionPtrOutput) ResponseHeaderModifier added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) ResponseHeaderModifier() HttpRouteRuleActionResponseHeaderModifierPtrOutput

The specification for modifying the headers of a response prior to sending the response back to the client. Structure is documented below.

func (HttpRouteRuleActionPtrOutput) RetryPolicy added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) RetryPolicy() HttpRouteRuleActionRetryPolicyPtrOutput

Specifies the retry policy associated with this route. Structure is documented below.

func (HttpRouteRuleActionPtrOutput) Timeout added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) Timeout() pulumi.StringPtrOutput

Specifies the timeout for selected route.

func (HttpRouteRuleActionPtrOutput) ToHttpRouteRuleActionPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) ToHttpRouteRuleActionPtrOutput() HttpRouteRuleActionPtrOutput

func (HttpRouteRuleActionPtrOutput) ToHttpRouteRuleActionPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) ToHttpRouteRuleActionPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionPtrOutput

func (HttpRouteRuleActionPtrOutput) UrlRewrite added in v6.55.0 

func (o HttpRouteRuleActionPtrOutput) UrlRewrite() HttpRouteRuleActionUrlRewritePtrOutput

The specification for rewrite URL before forwarding requests to the destination. Structure is documented below.

type HttpRouteRuleActionRedirect added in v6.55.0 

type HttpRouteRuleActionRedirect 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.
	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 can not 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.
	PathRedirect *string `pulumi:"pathRedirect"`
	// The port that will be used in the redirected request instead of the one that was supplied in the request.
	PortRedirect *int `pulumi:"portRedirect"`
	// Indicates that during redirection, the matched prefix (or path) should be swapped with this value.
	PrefixRewrite *string `pulumi:"prefixRewrite"`
	// The HTTP Status code to use for the redirect.
	ResponseCode *string `pulumi:"responseCode"`
	// If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request.
	StripQuery *bool `pulumi:"stripQuery"`
}

type HttpRouteRuleActionRedirectArgs added in v6.55.0 

type HttpRouteRuleActionRedirectArgs 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.
	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 can not 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.
	PathRedirect pulumi.StringPtrInput `pulumi:"pathRedirect"`
	// The port that will be used in the redirected request instead of the one that was supplied in the request.
	PortRedirect pulumi.IntPtrInput `pulumi:"portRedirect"`
	// Indicates that during redirection, the matched prefix (or path) should be swapped with this value.
	PrefixRewrite pulumi.StringPtrInput `pulumi:"prefixRewrite"`
	// The HTTP Status code to use for the redirect.
	ResponseCode pulumi.StringPtrInput `pulumi:"responseCode"`
	// If set to true, any accompanying query portion of the original URL is removed prior to redirecting the request.
	StripQuery pulumi.BoolPtrInput `pulumi:"stripQuery"`
}

func (HttpRouteRuleActionRedirectArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionRedirectArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectOutput added in v6.55.0 

func (i HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectOutput() HttpRouteRuleActionRedirectOutput

func (HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectOutputWithContext(ctx context.Context) HttpRouteRuleActionRedirectOutput

func (HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectPtrOutput() HttpRouteRuleActionRedirectPtrOutput

func (HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRedirectArgs) ToHttpRouteRuleActionRedirectPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRedirectPtrOutput

type HttpRouteRuleActionRedirectInput added in v6.55.0 

type HttpRouteRuleActionRedirectInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRedirectOutput() HttpRouteRuleActionRedirectOutput
	ToHttpRouteRuleActionRedirectOutputWithContext(context.Context) HttpRouteRuleActionRedirectOutput
}

HttpRouteRuleActionRedirectInput is an input type that accepts HttpRouteRuleActionRedirectArgs and HttpRouteRuleActionRedirectOutput values. You can construct a concrete instance of `HttpRouteRuleActionRedirectInput` via: 

HttpRouteRuleActionRedirectArgs{...}

type HttpRouteRuleActionRedirectOutput added in v6.55.0 

type HttpRouteRuleActionRedirectOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRedirectOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRedirectOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRedirectOutput) HostRedirect added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) HostRedirect() pulumi.StringPtrOutput

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

func (HttpRouteRuleActionRedirectOutput) HttpsRedirect added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) HttpsRedirect() pulumi.BoolPtrOutput

If set to true, the URL scheme in the redirected request is set to https.

func (HttpRouteRuleActionRedirectOutput) PathRedirect added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) PathRedirect() pulumi.StringPtrOutput

The path that will be used in the redirect response instead of the one that was supplied in the request. pathRedirect can not 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.

func (HttpRouteRuleActionRedirectOutput) PortRedirect added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) PortRedirect() pulumi.IntPtrOutput

The port that will be used in the redirected request instead of the one that was supplied in the request.

func (HttpRouteRuleActionRedirectOutput) PrefixRewrite added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) PrefixRewrite() pulumi.StringPtrOutput

Indicates that during redirection, the matched prefix (or path) should be swapped with this value.

func (HttpRouteRuleActionRedirectOutput) ResponseCode added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) ResponseCode() pulumi.StringPtrOutput

The HTTP Status code to use for the redirect.

func (HttpRouteRuleActionRedirectOutput) StripQuery added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) StripQuery() pulumi.BoolPtrOutput

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

func (HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectOutput added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectOutput() HttpRouteRuleActionRedirectOutput

func (HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectOutputWithContext(ctx context.Context) HttpRouteRuleActionRedirectOutput

func (HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectPtrOutput() HttpRouteRuleActionRedirectPtrOutput

func (HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRedirectOutput) ToHttpRouteRuleActionRedirectPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRedirectPtrOutput

type HttpRouteRuleActionRedirectPtrInput added in v6.55.0 

type HttpRouteRuleActionRedirectPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRedirectPtrOutput() HttpRouteRuleActionRedirectPtrOutput
	ToHttpRouteRuleActionRedirectPtrOutputWithContext(context.Context) HttpRouteRuleActionRedirectPtrOutput
}

HttpRouteRuleActionRedirectPtrInput is an input type that accepts HttpRouteRuleActionRedirectArgs, HttpRouteRuleActionRedirectPtr and HttpRouteRuleActionRedirectPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionRedirectPtrInput` via: 

        HttpRouteRuleActionRedirectArgs{...}

or:

        nil

func HttpRouteRuleActionRedirectPtr added in v6.55.0 

func HttpRouteRuleActionRedirectPtr(v *HttpRouteRuleActionRedirectArgs) HttpRouteRuleActionRedirectPtrInput

type HttpRouteRuleActionRedirectPtrOutput added in v6.55.0 

type HttpRouteRuleActionRedirectPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRedirectPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) Elem() HttpRouteRuleActionRedirectOutput

func (HttpRouteRuleActionRedirectPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRedirectPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRedirectPtrOutput) HostRedirect added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) HostRedirect() pulumi.StringPtrOutput

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

func (HttpRouteRuleActionRedirectPtrOutput) HttpsRedirect added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) HttpsRedirect() pulumi.BoolPtrOutput

If set to true, the URL scheme in the redirected request is set to https.

func (HttpRouteRuleActionRedirectPtrOutput) PathRedirect added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) PathRedirect() pulumi.StringPtrOutput

The path that will be used in the redirect response instead of the one that was supplied in the request. pathRedirect can not 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.

func (HttpRouteRuleActionRedirectPtrOutput) PortRedirect added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) PortRedirect() pulumi.IntPtrOutput

The port that will be used in the redirected request instead of the one that was supplied in the request.

func (HttpRouteRuleActionRedirectPtrOutput) PrefixRewrite added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) PrefixRewrite() pulumi.StringPtrOutput

Indicates that during redirection, the matched prefix (or path) should be swapped with this value.

func (HttpRouteRuleActionRedirectPtrOutput) ResponseCode added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) ResponseCode() pulumi.StringPtrOutput

The HTTP Status code to use for the redirect.

func (HttpRouteRuleActionRedirectPtrOutput) StripQuery added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) StripQuery() pulumi.BoolPtrOutput

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

func (HttpRouteRuleActionRedirectPtrOutput) ToHttpRouteRuleActionRedirectPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) ToHttpRouteRuleActionRedirectPtrOutput() HttpRouteRuleActionRedirectPtrOutput

func (HttpRouteRuleActionRedirectPtrOutput) ToHttpRouteRuleActionRedirectPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRedirectPtrOutput) ToHttpRouteRuleActionRedirectPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRedirectPtrOutput

type HttpRouteRuleActionRequestHeaderModifier added in v6.55.0 

type HttpRouteRuleActionRequestHeaderModifier struct {
	// Add the headers with given map where key is the name of the header, value is the value of the header.
	Add map[string]string `pulumi:"add"`
	// Remove headers (matching by header names) specified in the list.
	Removes []string `pulumi:"removes"`
	// Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
	Set map[string]string `pulumi:"set"`
}

type HttpRouteRuleActionRequestHeaderModifierArgs added in v6.55.0 

type HttpRouteRuleActionRequestHeaderModifierArgs struct {
	// Add the headers with given map where key is the name of the header, value is the value of the header.
	Add pulumi.StringMapInput `pulumi:"add"`
	// Remove headers (matching by header names) specified in the list.
	Removes pulumi.StringArrayInput `pulumi:"removes"`
	// Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
	Set pulumi.StringMapInput `pulumi:"set"`
}

func (HttpRouteRuleActionRequestHeaderModifierArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestHeaderModifierArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierOutput added in v6.55.0 

func (i HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierOutput() HttpRouteRuleActionRequestHeaderModifierOutput

func (HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestHeaderModifierOutput

func (HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput() HttpRouteRuleActionRequestHeaderModifierPtrOutput

func (HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRequestHeaderModifierArgs) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestHeaderModifierPtrOutput

type HttpRouteRuleActionRequestHeaderModifierInput added in v6.55.0 

type HttpRouteRuleActionRequestHeaderModifierInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRequestHeaderModifierOutput() HttpRouteRuleActionRequestHeaderModifierOutput
	ToHttpRouteRuleActionRequestHeaderModifierOutputWithContext(context.Context) HttpRouteRuleActionRequestHeaderModifierOutput
}

HttpRouteRuleActionRequestHeaderModifierInput is an input type that accepts HttpRouteRuleActionRequestHeaderModifierArgs and HttpRouteRuleActionRequestHeaderModifierOutput values. You can construct a concrete instance of `HttpRouteRuleActionRequestHeaderModifierInput` via: 

HttpRouteRuleActionRequestHeaderModifierArgs{...}

type HttpRouteRuleActionRequestHeaderModifierOutput added in v6.55.0 

type HttpRouteRuleActionRequestHeaderModifierOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestHeaderModifierOutput) Add added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) Add() pulumi.StringMapOutput

Add the headers with given map where key is the name of the header, value is the value of the header.

func (HttpRouteRuleActionRequestHeaderModifierOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestHeaderModifierOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestHeaderModifierOutput) Removes added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) Removes() pulumi.StringArrayOutput

Remove headers (matching by header names) specified in the list.

func (HttpRouteRuleActionRequestHeaderModifierOutput) Set added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) Set() pulumi.StringMapOutput

Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.

func (HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierOutput() HttpRouteRuleActionRequestHeaderModifierOutput

func (HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestHeaderModifierOutput

func (HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput() HttpRouteRuleActionRequestHeaderModifierPtrOutput

func (HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestHeaderModifierPtrOutput

type HttpRouteRuleActionRequestHeaderModifierPtrInput added in v6.55.0 

type HttpRouteRuleActionRequestHeaderModifierPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRequestHeaderModifierPtrOutput() HttpRouteRuleActionRequestHeaderModifierPtrOutput
	ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext(context.Context) HttpRouteRuleActionRequestHeaderModifierPtrOutput
}

HttpRouteRuleActionRequestHeaderModifierPtrInput is an input type that accepts HttpRouteRuleActionRequestHeaderModifierArgs, HttpRouteRuleActionRequestHeaderModifierPtr and HttpRouteRuleActionRequestHeaderModifierPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionRequestHeaderModifierPtrInput` via: 

        HttpRouteRuleActionRequestHeaderModifierArgs{...}

or:

        nil

func HttpRouteRuleActionRequestHeaderModifierPtr added in v6.55.0 

func HttpRouteRuleActionRequestHeaderModifierPtr(v *HttpRouteRuleActionRequestHeaderModifierArgs) HttpRouteRuleActionRequestHeaderModifierPtrInput

type HttpRouteRuleActionRequestHeaderModifierPtrOutput added in v6.55.0 

type HttpRouteRuleActionRequestHeaderModifierPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) Add added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) Add() pulumi.StringMapOutput

Add the headers with given map where key is the name of the header, value is the value of the header.

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) Elem() HttpRouteRuleActionRequestHeaderModifierOutput

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) Removes added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) Removes() pulumi.StringArrayOutput

Remove headers (matching by header names) specified in the list.

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) Set added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) Set() pulumi.StringMapOutput

Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutput() HttpRouteRuleActionRequestHeaderModifierPtrOutput

func (HttpRouteRuleActionRequestHeaderModifierPtrOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestHeaderModifierPtrOutput) ToHttpRouteRuleActionRequestHeaderModifierPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestHeaderModifierPtrOutput

type HttpRouteRuleActionRequestMirrorPolicy added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicy struct {
	// The destination the requests will be mirrored to.
	// Structure is documented below.
	Destination *HttpRouteRuleActionRequestMirrorPolicyDestination `pulumi:"destination"`
}

type HttpRouteRuleActionRequestMirrorPolicyArgs added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyArgs struct {
	// The destination the requests will be mirrored to.
	// Structure is documented below.
	Destination HttpRouteRuleActionRequestMirrorPolicyDestinationPtrInput `pulumi:"destination"`
}

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyOutput added in v6.55.0 

func (i HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyOutput() HttpRouteRuleActionRequestMirrorPolicyOutput

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyOutput

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput() HttpRouteRuleActionRequestMirrorPolicyPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRequestMirrorPolicyArgs) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyPtrOutput

type HttpRouteRuleActionRequestMirrorPolicyDestination added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyDestination struct {
	// The URL of a BackendService to route traffic to.
	ServiceName *string `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
	// If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
	// If weights are specified for any one service name, they need to be specified for all of them.
	// If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
	Weight *int `pulumi:"weight"`
}

type HttpRouteRuleActionRequestMirrorPolicyDestinationArgs added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyDestinationArgs struct {
	// The URL of a BackendService to route traffic to.
	ServiceName pulumi.StringPtrInput `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
	// If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
	// If weights are specified for any one service name, they need to be specified for all of them.
	// If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput added in v6.55.0 

func (i HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyDestinationOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

type HttpRouteRuleActionRequestMirrorPolicyDestinationInput added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyDestinationInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationOutput
	ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutputWithContext(context.Context) HttpRouteRuleActionRequestMirrorPolicyDestinationOutput
}

HttpRouteRuleActionRequestMirrorPolicyDestinationInput is an input type that accepts HttpRouteRuleActionRequestMirrorPolicyDestinationArgs and HttpRouteRuleActionRequestMirrorPolicyDestinationOutput values. You can construct a concrete instance of `HttpRouteRuleActionRequestMirrorPolicyDestinationInput` via: 

HttpRouteRuleActionRequestMirrorPolicyDestinationArgs{...}

type HttpRouteRuleActionRequestMirrorPolicyDestinationOutput added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyDestinationOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ServiceName added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyDestinationOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) Weight added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationOutput) Weight() pulumi.IntPtrOutput

Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports. If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend. If weights are specified for any one service name, they need to be specified for all of them. If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.

type HttpRouteRuleActionRequestMirrorPolicyDestinationPtrInput added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyDestinationPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput
	ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext(context.Context) HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput
}

HttpRouteRuleActionRequestMirrorPolicyDestinationPtrInput is an input type that accepts HttpRouteRuleActionRequestMirrorPolicyDestinationArgs, HttpRouteRuleActionRequestMirrorPolicyDestinationPtr and HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionRequestMirrorPolicyDestinationPtrInput` via: 

        HttpRouteRuleActionRequestMirrorPolicyDestinationArgs{...}

or:

        nil

func HttpRouteRuleActionRequestMirrorPolicyDestinationPtr added in v6.55.0 

func HttpRouteRuleActionRequestMirrorPolicyDestinationPtr(v *HttpRouteRuleActionRequestMirrorPolicyDestinationArgs) HttpRouteRuleActionRequestMirrorPolicyDestinationPtrInput

type HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) Elem() HttpRouteRuleActionRequestMirrorPolicyDestinationOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ServiceName added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) Weight added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput) Weight() pulumi.IntPtrOutput

Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports. If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend. If weights are specified for any one service name, they need to be specified for all of them. If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.

type HttpRouteRuleActionRequestMirrorPolicyInput added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRequestMirrorPolicyOutput() HttpRouteRuleActionRequestMirrorPolicyOutput
	ToHttpRouteRuleActionRequestMirrorPolicyOutputWithContext(context.Context) HttpRouteRuleActionRequestMirrorPolicyOutput
}

HttpRouteRuleActionRequestMirrorPolicyInput is an input type that accepts HttpRouteRuleActionRequestMirrorPolicyArgs and HttpRouteRuleActionRequestMirrorPolicyOutput values. You can construct a concrete instance of `HttpRouteRuleActionRequestMirrorPolicyInput` via: 

HttpRouteRuleActionRequestMirrorPolicyArgs{...}

type HttpRouteRuleActionRequestMirrorPolicyOutput added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestMirrorPolicyOutput) Destination added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyOutput) Destination() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

The destination the requests will be mirrored to. Structure is documented below.

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyOutput() HttpRouteRuleActionRequestMirrorPolicyOutput

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyOutput

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput() HttpRouteRuleActionRequestMirrorPolicyPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyPtrOutput

type HttpRouteRuleActionRequestMirrorPolicyPtrInput added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput() HttpRouteRuleActionRequestMirrorPolicyPtrOutput
	ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext(context.Context) HttpRouteRuleActionRequestMirrorPolicyPtrOutput
}

HttpRouteRuleActionRequestMirrorPolicyPtrInput is an input type that accepts HttpRouteRuleActionRequestMirrorPolicyArgs, HttpRouteRuleActionRequestMirrorPolicyPtr and HttpRouteRuleActionRequestMirrorPolicyPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionRequestMirrorPolicyPtrInput` via: 

        HttpRouteRuleActionRequestMirrorPolicyArgs{...}

or:

        nil

func HttpRouteRuleActionRequestMirrorPolicyPtr added in v6.55.0 

func HttpRouteRuleActionRequestMirrorPolicyPtr(v *HttpRouteRuleActionRequestMirrorPolicyArgs) HttpRouteRuleActionRequestMirrorPolicyPtrInput

type HttpRouteRuleActionRequestMirrorPolicyPtrOutput added in v6.55.0 

type HttpRouteRuleActionRequestMirrorPolicyPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) Destination added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyPtrOutput) Destination() HttpRouteRuleActionRequestMirrorPolicyDestinationPtrOutput

The destination the requests will be mirrored to. Structure is documented below.

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyPtrOutput) Elem() HttpRouteRuleActionRequestMirrorPolicyOutput

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutput() HttpRouteRuleActionRequestMirrorPolicyPtrOutput

func (HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRequestMirrorPolicyPtrOutput) ToHttpRouteRuleActionRequestMirrorPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRequestMirrorPolicyPtrOutput

type HttpRouteRuleActionResponseHeaderModifier added in v6.55.0 

type HttpRouteRuleActionResponseHeaderModifier struct {
	// Add the headers with given map where key is the name of the header, value is the value of the header.
	Add map[string]string `pulumi:"add"`
	// Remove headers (matching by header names) specified in the list.
	Removes []string `pulumi:"removes"`
	// Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
	Set map[string]string `pulumi:"set"`
}

type HttpRouteRuleActionResponseHeaderModifierArgs added in v6.55.0 

type HttpRouteRuleActionResponseHeaderModifierArgs struct {
	// Add the headers with given map where key is the name of the header, value is the value of the header.
	Add pulumi.StringMapInput `pulumi:"add"`
	// Remove headers (matching by header names) specified in the list.
	Removes pulumi.StringArrayInput `pulumi:"removes"`
	// Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.
	Set pulumi.StringMapInput `pulumi:"set"`
}

func (HttpRouteRuleActionResponseHeaderModifierArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionResponseHeaderModifierArgs) ElementType() reflect.Type

func (HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierOutput added in v6.55.0 

func (i HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierOutput() HttpRouteRuleActionResponseHeaderModifierOutput

func (HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierOutputWithContext(ctx context.Context) HttpRouteRuleActionResponseHeaderModifierOutput

func (HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput() HttpRouteRuleActionResponseHeaderModifierPtrOutput

func (HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionResponseHeaderModifierArgs) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionResponseHeaderModifierPtrOutput

type HttpRouteRuleActionResponseHeaderModifierInput added in v6.55.0 

type HttpRouteRuleActionResponseHeaderModifierInput interface {
	pulumi.Input

	ToHttpRouteRuleActionResponseHeaderModifierOutput() HttpRouteRuleActionResponseHeaderModifierOutput
	ToHttpRouteRuleActionResponseHeaderModifierOutputWithContext(context.Context) HttpRouteRuleActionResponseHeaderModifierOutput
}

HttpRouteRuleActionResponseHeaderModifierInput is an input type that accepts HttpRouteRuleActionResponseHeaderModifierArgs and HttpRouteRuleActionResponseHeaderModifierOutput values. You can construct a concrete instance of `HttpRouteRuleActionResponseHeaderModifierInput` via: 

HttpRouteRuleActionResponseHeaderModifierArgs{...}

type HttpRouteRuleActionResponseHeaderModifierOutput added in v6.55.0 

type HttpRouteRuleActionResponseHeaderModifierOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionResponseHeaderModifierOutput) Add added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) Add() pulumi.StringMapOutput

Add the headers with given map where key is the name of the header, value is the value of the header.

func (HttpRouteRuleActionResponseHeaderModifierOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionResponseHeaderModifierOutput) ElementType() reflect.Type

func (HttpRouteRuleActionResponseHeaderModifierOutput) Removes added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) Removes() pulumi.StringArrayOutput

Remove headers (matching by header names) specified in the list.

func (HttpRouteRuleActionResponseHeaderModifierOutput) Set added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) Set() pulumi.StringMapOutput

Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.

func (HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierOutput added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierOutput() HttpRouteRuleActionResponseHeaderModifierOutput

func (HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierOutputWithContext(ctx context.Context) HttpRouteRuleActionResponseHeaderModifierOutput

func (HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput() HttpRouteRuleActionResponseHeaderModifierPtrOutput

func (HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionResponseHeaderModifierPtrOutput

type HttpRouteRuleActionResponseHeaderModifierPtrInput added in v6.55.0 

type HttpRouteRuleActionResponseHeaderModifierPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionResponseHeaderModifierPtrOutput() HttpRouteRuleActionResponseHeaderModifierPtrOutput
	ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext(context.Context) HttpRouteRuleActionResponseHeaderModifierPtrOutput
}

HttpRouteRuleActionResponseHeaderModifierPtrInput is an input type that accepts HttpRouteRuleActionResponseHeaderModifierArgs, HttpRouteRuleActionResponseHeaderModifierPtr and HttpRouteRuleActionResponseHeaderModifierPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionResponseHeaderModifierPtrInput` via: 

        HttpRouteRuleActionResponseHeaderModifierArgs{...}

or:

        nil

func HttpRouteRuleActionResponseHeaderModifierPtr added in v6.55.0 

func HttpRouteRuleActionResponseHeaderModifierPtr(v *HttpRouteRuleActionResponseHeaderModifierArgs) HttpRouteRuleActionResponseHeaderModifierPtrInput

type HttpRouteRuleActionResponseHeaderModifierPtrOutput added in v6.55.0 

type HttpRouteRuleActionResponseHeaderModifierPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) Add added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) Add() pulumi.StringMapOutput

Add the headers with given map where key is the name of the header, value is the value of the header.

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) Elem() HttpRouteRuleActionResponseHeaderModifierOutput

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) Removes added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) Removes() pulumi.StringArrayOutput

Remove headers (matching by header names) specified in the list.

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) Set added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) Set() pulumi.StringMapOutput

Completely overwrite/replace the headers with given map where key is the name of the header, value is the value of the header.

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutput() HttpRouteRuleActionResponseHeaderModifierPtrOutput

func (HttpRouteRuleActionResponseHeaderModifierPtrOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionResponseHeaderModifierPtrOutput) ToHttpRouteRuleActionResponseHeaderModifierPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionResponseHeaderModifierPtrOutput

type HttpRouteRuleActionRetryPolicy added in v6.55.0 

type HttpRouteRuleActionRetryPolicy struct {
	// Specifies the allowed number of retries.
	NumRetries *int `pulumi:"numRetries"`
	// Specifies a non-zero timeout per retry attempt. A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
	PerTryTimeout *string `pulumi:"perTryTimeout"`
	// Specifies one or more conditions when this retry policy applies.
	RetryConditions []string `pulumi:"retryConditions"`
}

type HttpRouteRuleActionRetryPolicyArgs added in v6.55.0 

type HttpRouteRuleActionRetryPolicyArgs struct {
	// Specifies the allowed number of retries.
	NumRetries pulumi.IntPtrInput `pulumi:"numRetries"`
	// Specifies a non-zero timeout per retry attempt. A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".
	PerTryTimeout pulumi.StringPtrInput `pulumi:"perTryTimeout"`
	// Specifies one or more conditions when this retry policy applies.
	RetryConditions pulumi.StringArrayInput `pulumi:"retryConditions"`
}

func (HttpRouteRuleActionRetryPolicyArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionRetryPolicyArgs) ElementType() reflect.Type

func (HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyOutput added in v6.55.0 

func (i HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyOutput() HttpRouteRuleActionRetryPolicyOutput

func (HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyOutputWithContext(ctx context.Context) HttpRouteRuleActionRetryPolicyOutput

func (HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyPtrOutput added in v6.55.0 

func (i HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyPtrOutput() HttpRouteRuleActionRetryPolicyPtrOutput

func (HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionRetryPolicyArgs) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRetryPolicyPtrOutput

type HttpRouteRuleActionRetryPolicyInput added in v6.55.0 

type HttpRouteRuleActionRetryPolicyInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRetryPolicyOutput() HttpRouteRuleActionRetryPolicyOutput
	ToHttpRouteRuleActionRetryPolicyOutputWithContext(context.Context) HttpRouteRuleActionRetryPolicyOutput
}

HttpRouteRuleActionRetryPolicyInput is an input type that accepts HttpRouteRuleActionRetryPolicyArgs and HttpRouteRuleActionRetryPolicyOutput values. You can construct a concrete instance of `HttpRouteRuleActionRetryPolicyInput` via: 

HttpRouteRuleActionRetryPolicyArgs{...}

type HttpRouteRuleActionRetryPolicyOutput added in v6.55.0 

type HttpRouteRuleActionRetryPolicyOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRetryPolicyOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRetryPolicyOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRetryPolicyOutput) NumRetries added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyOutput) NumRetries() pulumi.IntPtrOutput

Specifies the allowed number of retries.

func (HttpRouteRuleActionRetryPolicyOutput) PerTryTimeout added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyOutput) PerTryTimeout() pulumi.StringPtrOutput

Specifies a non-zero timeout per retry attempt. A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

func (HttpRouteRuleActionRetryPolicyOutput) RetryConditions added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyOutput) RetryConditions() pulumi.StringArrayOutput

Specifies one or more conditions when this retry policy applies.

func (HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyOutput added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyOutput() HttpRouteRuleActionRetryPolicyOutput

func (HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyOutputWithContext(ctx context.Context) HttpRouteRuleActionRetryPolicyOutput

func (HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyPtrOutput() HttpRouteRuleActionRetryPolicyPtrOutput

func (HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyOutput) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRetryPolicyPtrOutput

type HttpRouteRuleActionRetryPolicyPtrInput added in v6.55.0 

type HttpRouteRuleActionRetryPolicyPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionRetryPolicyPtrOutput() HttpRouteRuleActionRetryPolicyPtrOutput
	ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext(context.Context) HttpRouteRuleActionRetryPolicyPtrOutput
}

HttpRouteRuleActionRetryPolicyPtrInput is an input type that accepts HttpRouteRuleActionRetryPolicyArgs, HttpRouteRuleActionRetryPolicyPtr and HttpRouteRuleActionRetryPolicyPtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionRetryPolicyPtrInput` via: 

        HttpRouteRuleActionRetryPolicyArgs{...}

or:

        nil

func HttpRouteRuleActionRetryPolicyPtr added in v6.55.0 

func HttpRouteRuleActionRetryPolicyPtr(v *HttpRouteRuleActionRetryPolicyArgs) HttpRouteRuleActionRetryPolicyPtrInput

type HttpRouteRuleActionRetryPolicyPtrOutput added in v6.55.0 

type HttpRouteRuleActionRetryPolicyPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionRetryPolicyPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) Elem() HttpRouteRuleActionRetryPolicyOutput

func (HttpRouteRuleActionRetryPolicyPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionRetryPolicyPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionRetryPolicyPtrOutput) NumRetries added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) NumRetries() pulumi.IntPtrOutput

Specifies the allowed number of retries.

func (HttpRouteRuleActionRetryPolicyPtrOutput) PerTryTimeout added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) PerTryTimeout() pulumi.StringPtrOutput

Specifies a non-zero timeout per retry attempt. A duration in seconds with up to nine fractional digits, ending with 's'. Example: "3.5s".

func (HttpRouteRuleActionRetryPolicyPtrOutput) RetryConditions added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) RetryConditions() pulumi.StringArrayOutput

Specifies one or more conditions when this retry policy applies.

func (HttpRouteRuleActionRetryPolicyPtrOutput) ToHttpRouteRuleActionRetryPolicyPtrOutput added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) ToHttpRouteRuleActionRetryPolicyPtrOutput() HttpRouteRuleActionRetryPolicyPtrOutput

func (HttpRouteRuleActionRetryPolicyPtrOutput) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionRetryPolicyPtrOutput) ToHttpRouteRuleActionRetryPolicyPtrOutputWithContext(ctx context.Context) HttpRouteRuleActionRetryPolicyPtrOutput

type HttpRouteRuleActionUrlRewrite added in v6.55.0 

type HttpRouteRuleActionUrlRewrite struct {
	// Prior to forwarding the request to the selected destination, the requests host header is replaced by this value.
	HostRewrite *string `pulumi:"hostRewrite"`
	// Prior to forwarding the request to the selected destination, the matching portion of the requests path is replaced by this value.
	PathPrefixRewrite *string `pulumi:"pathPrefixRewrite"`
}

type HttpRouteRuleActionUrlRewriteArgs added in v6.55.0 

type HttpRouteRuleActionUrlRewriteArgs struct {
	// Prior to forwarding the request to the selected destination, the requests host header is replaced by this value.
	HostRewrite pulumi.StringPtrInput `pulumi:"hostRewrite"`
	// Prior to forwarding the request to the selected destination, the matching portion of the requests path is replaced by this value.
	PathPrefixRewrite pulumi.StringPtrInput `pulumi:"pathPrefixRewrite"`
}

func (HttpRouteRuleActionUrlRewriteArgs) ElementType added in v6.55.0 

func (HttpRouteRuleActionUrlRewriteArgs) ElementType() reflect.Type

func (HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewriteOutput added in v6.55.0 

func (i HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewriteOutput() HttpRouteRuleActionUrlRewriteOutput

func (HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewriteOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewriteOutputWithContext(ctx context.Context) HttpRouteRuleActionUrlRewriteOutput

func (HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewritePtrOutput added in v6.55.0 

func (i HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewritePtrOutput() HttpRouteRuleActionUrlRewritePtrOutput

func (HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleActionUrlRewriteArgs) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext(ctx context.Context) HttpRouteRuleActionUrlRewritePtrOutput

type HttpRouteRuleActionUrlRewriteInput added in v6.55.0 

type HttpRouteRuleActionUrlRewriteInput interface {
	pulumi.Input

	ToHttpRouteRuleActionUrlRewriteOutput() HttpRouteRuleActionUrlRewriteOutput
	ToHttpRouteRuleActionUrlRewriteOutputWithContext(context.Context) HttpRouteRuleActionUrlRewriteOutput
}

HttpRouteRuleActionUrlRewriteInput is an input type that accepts HttpRouteRuleActionUrlRewriteArgs and HttpRouteRuleActionUrlRewriteOutput values. You can construct a concrete instance of `HttpRouteRuleActionUrlRewriteInput` via: 

HttpRouteRuleActionUrlRewriteArgs{...}

type HttpRouteRuleActionUrlRewriteOutput added in v6.55.0 

type HttpRouteRuleActionUrlRewriteOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionUrlRewriteOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionUrlRewriteOutput) ElementType() reflect.Type

func (HttpRouteRuleActionUrlRewriteOutput) HostRewrite added in v6.55.0 

func (o HttpRouteRuleActionUrlRewriteOutput) HostRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected destination, the requests host header is replaced by this value.

func (HttpRouteRuleActionUrlRewriteOutput) PathPrefixRewrite added in v6.55.0 

func (o HttpRouteRuleActionUrlRewriteOutput) PathPrefixRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected destination, the matching portion of the requests path is replaced by this value.

func (HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewriteOutput added in v6.55.0 

func (o HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewriteOutput() HttpRouteRuleActionUrlRewriteOutput

func (HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewriteOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewriteOutputWithContext(ctx context.Context) HttpRouteRuleActionUrlRewriteOutput

func (HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewritePtrOutput added in v6.55.0 

func (o HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewritePtrOutput() HttpRouteRuleActionUrlRewritePtrOutput

func (HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionUrlRewriteOutput) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext(ctx context.Context) HttpRouteRuleActionUrlRewritePtrOutput

type HttpRouteRuleActionUrlRewritePtrInput added in v6.55.0 

type HttpRouteRuleActionUrlRewritePtrInput interface {
	pulumi.Input

	ToHttpRouteRuleActionUrlRewritePtrOutput() HttpRouteRuleActionUrlRewritePtrOutput
	ToHttpRouteRuleActionUrlRewritePtrOutputWithContext(context.Context) HttpRouteRuleActionUrlRewritePtrOutput
}

HttpRouteRuleActionUrlRewritePtrInput is an input type that accepts HttpRouteRuleActionUrlRewriteArgs, HttpRouteRuleActionUrlRewritePtr and HttpRouteRuleActionUrlRewritePtrOutput values. You can construct a concrete instance of `HttpRouteRuleActionUrlRewritePtrInput` via: 

        HttpRouteRuleActionUrlRewriteArgs{...}

or:

        nil

func HttpRouteRuleActionUrlRewritePtr added in v6.55.0 

func HttpRouteRuleActionUrlRewritePtr(v *HttpRouteRuleActionUrlRewriteArgs) HttpRouteRuleActionUrlRewritePtrInput

type HttpRouteRuleActionUrlRewritePtrOutput added in v6.55.0 

type HttpRouteRuleActionUrlRewritePtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleActionUrlRewritePtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleActionUrlRewritePtrOutput) Elem() HttpRouteRuleActionUrlRewriteOutput

func (HttpRouteRuleActionUrlRewritePtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleActionUrlRewritePtrOutput) ElementType() reflect.Type

func (HttpRouteRuleActionUrlRewritePtrOutput) HostRewrite added in v6.55.0 

func (o HttpRouteRuleActionUrlRewritePtrOutput) HostRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected destination, the requests host header is replaced by this value.

func (HttpRouteRuleActionUrlRewritePtrOutput) PathPrefixRewrite added in v6.55.0 

func (o HttpRouteRuleActionUrlRewritePtrOutput) PathPrefixRewrite() pulumi.StringPtrOutput

Prior to forwarding the request to the selected destination, the matching portion of the requests path is replaced by this value.

func (HttpRouteRuleActionUrlRewritePtrOutput) ToHttpRouteRuleActionUrlRewritePtrOutput added in v6.55.0 

func (o HttpRouteRuleActionUrlRewritePtrOutput) ToHttpRouteRuleActionUrlRewritePtrOutput() HttpRouteRuleActionUrlRewritePtrOutput

func (HttpRouteRuleActionUrlRewritePtrOutput) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleActionUrlRewritePtrOutput) ToHttpRouteRuleActionUrlRewritePtrOutputWithContext(ctx context.Context) HttpRouteRuleActionUrlRewritePtrOutput

type HttpRouteRuleArgs added in v6.55.0 

type HttpRouteRuleArgs struct {
	// The detailed rule defining how to route matched traffic.
	// Structure is documented below.
	Action HttpRouteRuleActionPtrInput `pulumi:"action"`
	// A list of matches define conditions used for matching the rule against incoming HTTP requests. Each match is independent, i.e. this rule will be matched if ANY one of the matches is satisfied.
	// If no matches field is specified, this rule will unconditionally match traffic.
	// If a default rule is desired to be configured, add a rule with no matches specified to the end of the rules list.
	// Structure is documented below.
	Matches HttpRouteRuleMatchArrayInput `pulumi:"matches"`
}

func (HttpRouteRuleArgs) ElementType added in v6.55.0 

func (HttpRouteRuleArgs) ElementType() reflect.Type

func (HttpRouteRuleArgs) ToHttpRouteRuleOutput added in v6.55.0 

func (i HttpRouteRuleArgs) ToHttpRouteRuleOutput() HttpRouteRuleOutput

func (HttpRouteRuleArgs) ToHttpRouteRuleOutputWithContext added in v6.55.0 

func (i HttpRouteRuleArgs) ToHttpRouteRuleOutputWithContext(ctx context.Context) HttpRouteRuleOutput

type HttpRouteRuleArray added in v6.55.0 

type HttpRouteRuleArray []HttpRouteRuleInput

func (HttpRouteRuleArray) ElementType added in v6.55.0 

func (HttpRouteRuleArray) ElementType() reflect.Type

func (HttpRouteRuleArray) ToHttpRouteRuleArrayOutput added in v6.55.0 

func (i HttpRouteRuleArray) ToHttpRouteRuleArrayOutput() HttpRouteRuleArrayOutput

func (HttpRouteRuleArray) ToHttpRouteRuleArrayOutputWithContext added in v6.55.0 

func (i HttpRouteRuleArray) ToHttpRouteRuleArrayOutputWithContext(ctx context.Context) HttpRouteRuleArrayOutput

type HttpRouteRuleArrayInput added in v6.55.0 

type HttpRouteRuleArrayInput interface {
	pulumi.Input

	ToHttpRouteRuleArrayOutput() HttpRouteRuleArrayOutput
	ToHttpRouteRuleArrayOutputWithContext(context.Context) HttpRouteRuleArrayOutput
}

HttpRouteRuleArrayInput is an input type that accepts HttpRouteRuleArray and HttpRouteRuleArrayOutput values. You can construct a concrete instance of `HttpRouteRuleArrayInput` via: 

HttpRouteRuleArray{ HttpRouteRuleArgs{...} }

type HttpRouteRuleArrayOutput added in v6.55.0 

type HttpRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleArrayOutput) ElementType added in v6.55.0 

func (HttpRouteRuleArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleArrayOutput) Index added in v6.55.0 

func (o HttpRouteRuleArrayOutput) Index(i pulumi.IntInput) HttpRouteRuleOutput

func (HttpRouteRuleArrayOutput) ToHttpRouteRuleArrayOutput added in v6.55.0 

func (o HttpRouteRuleArrayOutput) ToHttpRouteRuleArrayOutput() HttpRouteRuleArrayOutput

func (HttpRouteRuleArrayOutput) ToHttpRouteRuleArrayOutputWithContext added in v6.55.0 

func (o HttpRouteRuleArrayOutput) ToHttpRouteRuleArrayOutputWithContext(ctx context.Context) HttpRouteRuleArrayOutput

type HttpRouteRuleInput added in v6.55.0 

type HttpRouteRuleInput interface {
	pulumi.Input

	ToHttpRouteRuleOutput() HttpRouteRuleOutput
	ToHttpRouteRuleOutputWithContext(context.Context) HttpRouteRuleOutput
}

HttpRouteRuleInput is an input type that accepts HttpRouteRuleArgs and HttpRouteRuleOutput values. You can construct a concrete instance of `HttpRouteRuleInput` via: 

HttpRouteRuleArgs{...}

type HttpRouteRuleMatch added in v6.55.0 

type HttpRouteRuleMatch struct {
	// The HTTP request path value should exactly match this value.
	FullPathMatch *string `pulumi:"fullPathMatch"`
	// Specifies a list of HTTP request headers to match against.
	// Structure is documented below.
	Headers []HttpRouteRuleMatchHeader `pulumi:"headers"`
	// Specifies if prefixMatch and fullPathMatch matches are case sensitive. The default value is false.
	IgnoreCase *bool `pulumi:"ignoreCase"`
	// The HTTP request path value must begin with specified prefixMatch. prefixMatch must begin with a /.
	PrefixMatch *string `pulumi:"prefixMatch"`
	// Specifies a list of query parameters to match against.
	// Structure is documented below.
	QueryParameters []HttpRouteRuleMatchQueryParameter `pulumi:"queryParameters"`
	// The HTTP request path value must satisfy the regular expression specified by regexMatch after removing any query parameters and anchor supplied with the original URL. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
	RegexMatch *string `pulumi:"regexMatch"`
}

type HttpRouteRuleMatchArgs added in v6.55.0 

type HttpRouteRuleMatchArgs struct {
	// The HTTP request path value should exactly match this value.
	FullPathMatch pulumi.StringPtrInput `pulumi:"fullPathMatch"`
	// Specifies a list of HTTP request headers to match against.
	// Structure is documented below.
	Headers HttpRouteRuleMatchHeaderArrayInput `pulumi:"headers"`
	// Specifies if prefixMatch and fullPathMatch matches are case sensitive. The default value is false.
	IgnoreCase pulumi.BoolPtrInput `pulumi:"ignoreCase"`
	// The HTTP request path value must begin with specified prefixMatch. prefixMatch must begin with a /.
	PrefixMatch pulumi.StringPtrInput `pulumi:"prefixMatch"`
	// Specifies a list of query parameters to match against.
	// Structure is documented below.
	QueryParameters HttpRouteRuleMatchQueryParameterArrayInput `pulumi:"queryParameters"`
	// The HTTP request path value must satisfy the regular expression specified by regexMatch after removing any query parameters and anchor supplied with the original URL. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
	RegexMatch pulumi.StringPtrInput `pulumi:"regexMatch"`
}

func (HttpRouteRuleMatchArgs) ElementType added in v6.55.0 

func (HttpRouteRuleMatchArgs) ElementType() reflect.Type

func (HttpRouteRuleMatchArgs) ToHttpRouteRuleMatchOutput added in v6.55.0 

func (i HttpRouteRuleMatchArgs) ToHttpRouteRuleMatchOutput() HttpRouteRuleMatchOutput

func (HttpRouteRuleMatchArgs) ToHttpRouteRuleMatchOutputWithContext added in v6.55.0 

func (i HttpRouteRuleMatchArgs) ToHttpRouteRuleMatchOutputWithContext(ctx context.Context) HttpRouteRuleMatchOutput

type HttpRouteRuleMatchArray added in v6.55.0 

type HttpRouteRuleMatchArray []HttpRouteRuleMatchInput

func (HttpRouteRuleMatchArray) ElementType added in v6.55.0 

func (HttpRouteRuleMatchArray) ElementType() reflect.Type

func (HttpRouteRuleMatchArray) ToHttpRouteRuleMatchArrayOutput added in v6.55.0 

func (i HttpRouteRuleMatchArray) ToHttpRouteRuleMatchArrayOutput() HttpRouteRuleMatchArrayOutput

func (HttpRouteRuleMatchArray) ToHttpRouteRuleMatchArrayOutputWithContext added in v6.55.0 

func (i HttpRouteRuleMatchArray) ToHttpRouteRuleMatchArrayOutputWithContext(ctx context.Context) HttpRouteRuleMatchArrayOutput

type HttpRouteRuleMatchArrayInput added in v6.55.0 

type HttpRouteRuleMatchArrayInput interface {
	pulumi.Input

	ToHttpRouteRuleMatchArrayOutput() HttpRouteRuleMatchArrayOutput
	ToHttpRouteRuleMatchArrayOutputWithContext(context.Context) HttpRouteRuleMatchArrayOutput
}

HttpRouteRuleMatchArrayInput is an input type that accepts HttpRouteRuleMatchArray and HttpRouteRuleMatchArrayOutput values. You can construct a concrete instance of `HttpRouteRuleMatchArrayInput` via: 

HttpRouteRuleMatchArray{ HttpRouteRuleMatchArgs{...} }

type HttpRouteRuleMatchArrayOutput added in v6.55.0 

type HttpRouteRuleMatchArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchArrayOutput) ElementType added in v6.55.0 

func (HttpRouteRuleMatchArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchArrayOutput) Index added in v6.55.0 

func (o HttpRouteRuleMatchArrayOutput) Index(i pulumi.IntInput) HttpRouteRuleMatchOutput

func (HttpRouteRuleMatchArrayOutput) ToHttpRouteRuleMatchArrayOutput added in v6.55.0 

func (o HttpRouteRuleMatchArrayOutput) ToHttpRouteRuleMatchArrayOutput() HttpRouteRuleMatchArrayOutput

func (HttpRouteRuleMatchArrayOutput) ToHttpRouteRuleMatchArrayOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchArrayOutput) ToHttpRouteRuleMatchArrayOutputWithContext(ctx context.Context) HttpRouteRuleMatchArrayOutput

type HttpRouteRuleMatchHeader added in v6.55.0 

type HttpRouteRuleMatchHeader struct {
	// The value of the header should match exactly the content of exactMatch.
	ExactMatch *string `pulumi:"exactMatch"`
	// The name of the HTTP header to match against.
	Header *string `pulumi:"header"`
	// If specified, the match result will be inverted before checking. Default value is set to false.
	InvertMatch *bool `pulumi:"invertMatch"`
	// The value of the header must start with the contents of prefixMatch.
	PrefixMatch *string `pulumi:"prefixMatch"`
	// A header with headerName must exist. The match takes place whether or not the header has a value.
	PresentMatch *bool `pulumi:"presentMatch"`
	// If specified, the rule will match if the request header value is within the range.
	// Structure is documented below.
	RangeMatch *HttpRouteRuleMatchHeaderRangeMatch `pulumi:"rangeMatch"`
	// The value of the header must match the regular expression specified in regexMatch.
	RegexMatch *string `pulumi:"regexMatch"`
	// The value of the header must end with the contents of suffixMatch.
	SuffixMatch *string `pulumi:"suffixMatch"`
}

type HttpRouteRuleMatchHeaderArgs added in v6.55.0 

type HttpRouteRuleMatchHeaderArgs struct {
	// The value of the header should match exactly the content of exactMatch.
	ExactMatch pulumi.StringPtrInput `pulumi:"exactMatch"`
	// The name of the HTTP header to match against.
	Header pulumi.StringPtrInput `pulumi:"header"`
	// If specified, the match result will be inverted before checking. Default value is set to false.
	InvertMatch pulumi.BoolPtrInput `pulumi:"invertMatch"`
	// The value of the header must start with the contents of prefixMatch.
	PrefixMatch pulumi.StringPtrInput `pulumi:"prefixMatch"`
	// A header with headerName must exist. The match takes place whether or not the header has a value.
	PresentMatch pulumi.BoolPtrInput `pulumi:"presentMatch"`
	// If specified, the rule will match if the request header value is within the range.
	// Structure is documented below.
	RangeMatch HttpRouteRuleMatchHeaderRangeMatchPtrInput `pulumi:"rangeMatch"`
	// The value of the header must match the regular expression specified in regexMatch.
	RegexMatch pulumi.StringPtrInput `pulumi:"regexMatch"`
	// The value of the header must end with the contents of suffixMatch.
	SuffixMatch pulumi.StringPtrInput `pulumi:"suffixMatch"`
}

func (HttpRouteRuleMatchHeaderArgs) ElementType added in v6.55.0 

func (HttpRouteRuleMatchHeaderArgs) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderArgs) ToHttpRouteRuleMatchHeaderOutput added in v6.55.0 

func (i HttpRouteRuleMatchHeaderArgs) ToHttpRouteRuleMatchHeaderOutput() HttpRouteRuleMatchHeaderOutput

func (HttpRouteRuleMatchHeaderArgs) ToHttpRouteRuleMatchHeaderOutputWithContext added in v6.55.0 

func (i HttpRouteRuleMatchHeaderArgs) ToHttpRouteRuleMatchHeaderOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderOutput

type HttpRouteRuleMatchHeaderArray added in v6.55.0 

type HttpRouteRuleMatchHeaderArray []HttpRouteRuleMatchHeaderInput

func (HttpRouteRuleMatchHeaderArray) ElementType added in v6.55.0 

func (HttpRouteRuleMatchHeaderArray) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderArray) ToHttpRouteRuleMatchHeaderArrayOutput added in v6.55.0 

func (i HttpRouteRuleMatchHeaderArray) ToHttpRouteRuleMatchHeaderArrayOutput() HttpRouteRuleMatchHeaderArrayOutput

func (HttpRouteRuleMatchHeaderArray) ToHttpRouteRuleMatchHeaderArrayOutputWithContext added in v6.55.0 

func (i HttpRouteRuleMatchHeaderArray) ToHttpRouteRuleMatchHeaderArrayOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderArrayOutput

type HttpRouteRuleMatchHeaderArrayInput added in v6.55.0 

type HttpRouteRuleMatchHeaderArrayInput interface {
	pulumi.Input

	ToHttpRouteRuleMatchHeaderArrayOutput() HttpRouteRuleMatchHeaderArrayOutput
	ToHttpRouteRuleMatchHeaderArrayOutputWithContext(context.Context) HttpRouteRuleMatchHeaderArrayOutput
}

HttpRouteRuleMatchHeaderArrayInput is an input type that accepts HttpRouteRuleMatchHeaderArray and HttpRouteRuleMatchHeaderArrayOutput values. You can construct a concrete instance of `HttpRouteRuleMatchHeaderArrayInput` via: 

HttpRouteRuleMatchHeaderArray{ HttpRouteRuleMatchHeaderArgs{...} }

type HttpRouteRuleMatchHeaderArrayOutput added in v6.55.0 

type HttpRouteRuleMatchHeaderArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchHeaderArrayOutput) ElementType added in v6.55.0 

func (HttpRouteRuleMatchHeaderArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderArrayOutput) Index added in v6.55.0 

func (o HttpRouteRuleMatchHeaderArrayOutput) Index(i pulumi.IntInput) HttpRouteRuleMatchHeaderOutput

func (HttpRouteRuleMatchHeaderArrayOutput) ToHttpRouteRuleMatchHeaderArrayOutput added in v6.55.0 

func (o HttpRouteRuleMatchHeaderArrayOutput) ToHttpRouteRuleMatchHeaderArrayOutput() HttpRouteRuleMatchHeaderArrayOutput

func (HttpRouteRuleMatchHeaderArrayOutput) ToHttpRouteRuleMatchHeaderArrayOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchHeaderArrayOutput) ToHttpRouteRuleMatchHeaderArrayOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderArrayOutput

type HttpRouteRuleMatchHeaderInput added in v6.55.0 

type HttpRouteRuleMatchHeaderInput interface {
	pulumi.Input

	ToHttpRouteRuleMatchHeaderOutput() HttpRouteRuleMatchHeaderOutput
	ToHttpRouteRuleMatchHeaderOutputWithContext(context.Context) HttpRouteRuleMatchHeaderOutput
}

HttpRouteRuleMatchHeaderInput is an input type that accepts HttpRouteRuleMatchHeaderArgs and HttpRouteRuleMatchHeaderOutput values. You can construct a concrete instance of `HttpRouteRuleMatchHeaderInput` via: 

HttpRouteRuleMatchHeaderArgs{...}

type HttpRouteRuleMatchHeaderOutput added in v6.55.0 

type HttpRouteRuleMatchHeaderOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchHeaderOutput) ElementType added in v6.55.0 

func (HttpRouteRuleMatchHeaderOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderOutput) ExactMatch added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) ExactMatch() pulumi.StringPtrOutput

The value of the header should match exactly the content of exactMatch.

func (HttpRouteRuleMatchHeaderOutput) Header added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) Header() pulumi.StringPtrOutput

The name of the HTTP header to match against.

func (HttpRouteRuleMatchHeaderOutput) InvertMatch added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) InvertMatch() pulumi.BoolPtrOutput

If specified, the match result will be inverted before checking. Default value is set to false.

func (HttpRouteRuleMatchHeaderOutput) PrefixMatch added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) PrefixMatch() pulumi.StringPtrOutput

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

func (HttpRouteRuleMatchHeaderOutput) PresentMatch added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) PresentMatch() pulumi.BoolPtrOutput

A header with headerName must exist. The match takes place whether or not the header has a value.

func (HttpRouteRuleMatchHeaderOutput) RangeMatch added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) RangeMatch() HttpRouteRuleMatchHeaderRangeMatchPtrOutput

If specified, the rule will match if the request header value is within the range. Structure is documented below.

func (HttpRouteRuleMatchHeaderOutput) RegexMatch added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) RegexMatch() pulumi.StringPtrOutput

The value of the header must match the regular expression specified in regexMatch.

func (HttpRouteRuleMatchHeaderOutput) SuffixMatch added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) SuffixMatch() pulumi.StringPtrOutput

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

func (HttpRouteRuleMatchHeaderOutput) ToHttpRouteRuleMatchHeaderOutput added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) ToHttpRouteRuleMatchHeaderOutput() HttpRouteRuleMatchHeaderOutput

func (HttpRouteRuleMatchHeaderOutput) ToHttpRouteRuleMatchHeaderOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchHeaderOutput) ToHttpRouteRuleMatchHeaderOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderOutput

type HttpRouteRuleMatchHeaderRangeMatch added in v6.55.0 

type HttpRouteRuleMatchHeaderRangeMatch struct {
	// End of the range (exclusive).
	End int `pulumi:"end"`
	// Start of the range (inclusive).
	Start int `pulumi:"start"`
}

type HttpRouteRuleMatchHeaderRangeMatchArgs added in v6.55.0 

type HttpRouteRuleMatchHeaderRangeMatchArgs struct {
	// End of the range (exclusive).
	End pulumi.IntInput `pulumi:"end"`
	// Start of the range (inclusive).
	Start pulumi.IntInput `pulumi:"start"`
}

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ElementType added in v6.55.0 

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchOutput added in v6.55.0 

func (i HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchOutput() HttpRouteRuleMatchHeaderRangeMatchOutput

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchOutputWithContext added in v6.55.0 

func (i HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderRangeMatchOutput

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput added in v6.55.0 

func (i HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput() HttpRouteRuleMatchHeaderRangeMatchPtrOutput

func (HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext added in v6.55.0 

func (i HttpRouteRuleMatchHeaderRangeMatchArgs) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderRangeMatchPtrOutput

type HttpRouteRuleMatchHeaderRangeMatchInput added in v6.55.0 

type HttpRouteRuleMatchHeaderRangeMatchInput interface {
	pulumi.Input

	ToHttpRouteRuleMatchHeaderRangeMatchOutput() HttpRouteRuleMatchHeaderRangeMatchOutput
	ToHttpRouteRuleMatchHeaderRangeMatchOutputWithContext(context.Context) HttpRouteRuleMatchHeaderRangeMatchOutput
}

HttpRouteRuleMatchHeaderRangeMatchInput is an input type that accepts HttpRouteRuleMatchHeaderRangeMatchArgs and HttpRouteRuleMatchHeaderRangeMatchOutput values. You can construct a concrete instance of `HttpRouteRuleMatchHeaderRangeMatchInput` via: 

HttpRouteRuleMatchHeaderRangeMatchArgs{...}

type HttpRouteRuleMatchHeaderRangeMatchOutput added in v6.55.0 

type HttpRouteRuleMatchHeaderRangeMatchOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ElementType added in v6.55.0 

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderRangeMatchOutput) End added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) End() pulumi.IntOutput

End of the range (exclusive).

func (HttpRouteRuleMatchHeaderRangeMatchOutput) Start added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) Start() pulumi.IntOutput

Start of the range (inclusive).

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchOutput added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchOutput() HttpRouteRuleMatchHeaderRangeMatchOutput

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderRangeMatchOutput

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput() HttpRouteRuleMatchHeaderRangeMatchPtrOutput

func (HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderRangeMatchPtrOutput

type HttpRouteRuleMatchHeaderRangeMatchPtrInput added in v6.55.0 

type HttpRouteRuleMatchHeaderRangeMatchPtrInput interface {
	pulumi.Input

	ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput() HttpRouteRuleMatchHeaderRangeMatchPtrOutput
	ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext(context.Context) HttpRouteRuleMatchHeaderRangeMatchPtrOutput
}

HttpRouteRuleMatchHeaderRangeMatchPtrInput is an input type that accepts HttpRouteRuleMatchHeaderRangeMatchArgs, HttpRouteRuleMatchHeaderRangeMatchPtr and HttpRouteRuleMatchHeaderRangeMatchPtrOutput values. You can construct a concrete instance of `HttpRouteRuleMatchHeaderRangeMatchPtrInput` via: 

        HttpRouteRuleMatchHeaderRangeMatchArgs{...}

or:

        nil

func HttpRouteRuleMatchHeaderRangeMatchPtr added in v6.55.0 

func HttpRouteRuleMatchHeaderRangeMatchPtr(v *HttpRouteRuleMatchHeaderRangeMatchArgs) HttpRouteRuleMatchHeaderRangeMatchPtrInput

type HttpRouteRuleMatchHeaderRangeMatchPtrOutput added in v6.55.0 

type HttpRouteRuleMatchHeaderRangeMatchPtrOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) Elem added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) Elem() HttpRouteRuleMatchHeaderRangeMatchOutput

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ElementType added in v6.55.0 

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) End added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) End() pulumi.IntPtrOutput

End of the range (exclusive).

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) Start added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) Start() pulumi.IntPtrOutput

Start of the range (inclusive).

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutput() HttpRouteRuleMatchHeaderRangeMatchPtrOutput

func (HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchHeaderRangeMatchPtrOutput) ToHttpRouteRuleMatchHeaderRangeMatchPtrOutputWithContext(ctx context.Context) HttpRouteRuleMatchHeaderRangeMatchPtrOutput

type HttpRouteRuleMatchInput added in v6.55.0 

type HttpRouteRuleMatchInput interface {
	pulumi.Input

	ToHttpRouteRuleMatchOutput() HttpRouteRuleMatchOutput
	ToHttpRouteRuleMatchOutputWithContext(context.Context) HttpRouteRuleMatchOutput
}

HttpRouteRuleMatchInput is an input type that accepts HttpRouteRuleMatchArgs and HttpRouteRuleMatchOutput values. You can construct a concrete instance of `HttpRouteRuleMatchInput` via: 

HttpRouteRuleMatchArgs{...}

type HttpRouteRuleMatchOutput added in v6.55.0 

type HttpRouteRuleMatchOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchOutput) ElementType added in v6.55.0 

func (HttpRouteRuleMatchOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchOutput) FullPathMatch added in v6.55.0 

func (o HttpRouteRuleMatchOutput) FullPathMatch() pulumi.StringPtrOutput

The HTTP request path value should exactly match this value.

func (HttpRouteRuleMatchOutput) Headers added in v6.55.0 

func (o HttpRouteRuleMatchOutput) Headers() HttpRouteRuleMatchHeaderArrayOutput

Specifies a list of HTTP request headers to match against. Structure is documented below.

func (HttpRouteRuleMatchOutput) IgnoreCase added in v6.55.0 

func (o HttpRouteRuleMatchOutput) IgnoreCase() pulumi.BoolPtrOutput

Specifies if prefixMatch and fullPathMatch matches are case sensitive. The default value is false.

func (HttpRouteRuleMatchOutput) PrefixMatch added in v6.55.0 

func (o HttpRouteRuleMatchOutput) PrefixMatch() pulumi.StringPtrOutput

The HTTP request path value must begin with specified prefixMatch. prefixMatch must begin with a /.

func (HttpRouteRuleMatchOutput) QueryParameters added in v6.55.0 

func (o HttpRouteRuleMatchOutput) QueryParameters() HttpRouteRuleMatchQueryParameterArrayOutput

Specifies a list of query parameters to match against. Structure is documented below.

func (HttpRouteRuleMatchOutput) RegexMatch added in v6.55.0 

func (o HttpRouteRuleMatchOutput) RegexMatch() pulumi.StringPtrOutput

The HTTP request path value must satisfy the regular expression specified by regexMatch after removing any query parameters and anchor supplied with the original URL. For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax

func (HttpRouteRuleMatchOutput) ToHttpRouteRuleMatchOutput added in v6.55.0 

func (o HttpRouteRuleMatchOutput) ToHttpRouteRuleMatchOutput() HttpRouteRuleMatchOutput

func (HttpRouteRuleMatchOutput) ToHttpRouteRuleMatchOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchOutput) ToHttpRouteRuleMatchOutputWithContext(ctx context.Context) HttpRouteRuleMatchOutput

type HttpRouteRuleMatchQueryParameter added in v6.55.0 

type HttpRouteRuleMatchQueryParameter struct {
	// The value of the query parameter must exactly match the contents of exactMatch.
	ExactMatch *string `pulumi:"exactMatch"`
	// Specifies that the QueryParameterMatcher matches if request contains query parameter, irrespective of whether the parameter has a value or not.
	PresentMatch *bool `pulumi:"presentMatch"`
	// The name of the query parameter to match.
	QueryParameter *string `pulumi:"queryParameter"`
	// The value of the query parameter must match the regular expression specified by regexMatch.For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
	RegexMatch *string `pulumi:"regexMatch"`
}

type HttpRouteRuleMatchQueryParameterArgs added in v6.55.0 

type HttpRouteRuleMatchQueryParameterArgs struct {
	// The value of the query parameter must exactly match the contents of exactMatch.
	ExactMatch pulumi.StringPtrInput `pulumi:"exactMatch"`
	// Specifies that the QueryParameterMatcher matches if request contains query parameter, irrespective of whether the parameter has a value or not.
	PresentMatch pulumi.BoolPtrInput `pulumi:"presentMatch"`
	// The name of the query parameter to match.
	QueryParameter pulumi.StringPtrInput `pulumi:"queryParameter"`
	// The value of the query parameter must match the regular expression specified by regexMatch.For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax
	RegexMatch pulumi.StringPtrInput `pulumi:"regexMatch"`
}

func (HttpRouteRuleMatchQueryParameterArgs) ElementType added in v6.55.0 

func (HttpRouteRuleMatchQueryParameterArgs) ElementType() reflect.Type

func (HttpRouteRuleMatchQueryParameterArgs) ToHttpRouteRuleMatchQueryParameterOutput added in v6.55.0 

func (i HttpRouteRuleMatchQueryParameterArgs) ToHttpRouteRuleMatchQueryParameterOutput() HttpRouteRuleMatchQueryParameterOutput

func (HttpRouteRuleMatchQueryParameterArgs) ToHttpRouteRuleMatchQueryParameterOutputWithContext added in v6.55.0 

func (i HttpRouteRuleMatchQueryParameterArgs) ToHttpRouteRuleMatchQueryParameterOutputWithContext(ctx context.Context) HttpRouteRuleMatchQueryParameterOutput

type HttpRouteRuleMatchQueryParameterArray added in v6.55.0 

type HttpRouteRuleMatchQueryParameterArray []HttpRouteRuleMatchQueryParameterInput

func (HttpRouteRuleMatchQueryParameterArray) ElementType added in v6.55.0 

func (HttpRouteRuleMatchQueryParameterArray) ElementType() reflect.Type

func (HttpRouteRuleMatchQueryParameterArray) ToHttpRouteRuleMatchQueryParameterArrayOutput added in v6.55.0 

func (i HttpRouteRuleMatchQueryParameterArray) ToHttpRouteRuleMatchQueryParameterArrayOutput() HttpRouteRuleMatchQueryParameterArrayOutput

func (HttpRouteRuleMatchQueryParameterArray) ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext added in v6.55.0 

func (i HttpRouteRuleMatchQueryParameterArray) ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext(ctx context.Context) HttpRouteRuleMatchQueryParameterArrayOutput

type HttpRouteRuleMatchQueryParameterArrayInput added in v6.55.0 

type HttpRouteRuleMatchQueryParameterArrayInput interface {
	pulumi.Input

	ToHttpRouteRuleMatchQueryParameterArrayOutput() HttpRouteRuleMatchQueryParameterArrayOutput
	ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext(context.Context) HttpRouteRuleMatchQueryParameterArrayOutput
}

HttpRouteRuleMatchQueryParameterArrayInput is an input type that accepts HttpRouteRuleMatchQueryParameterArray and HttpRouteRuleMatchQueryParameterArrayOutput values. You can construct a concrete instance of `HttpRouteRuleMatchQueryParameterArrayInput` via: 

HttpRouteRuleMatchQueryParameterArray{ HttpRouteRuleMatchQueryParameterArgs{...} }

type HttpRouteRuleMatchQueryParameterArrayOutput added in v6.55.0 

type HttpRouteRuleMatchQueryParameterArrayOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchQueryParameterArrayOutput) ElementType added in v6.55.0 

func (HttpRouteRuleMatchQueryParameterArrayOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchQueryParameterArrayOutput) Index added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterArrayOutput) Index(i pulumi.IntInput) HttpRouteRuleMatchQueryParameterOutput

func (HttpRouteRuleMatchQueryParameterArrayOutput) ToHttpRouteRuleMatchQueryParameterArrayOutput added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterArrayOutput) ToHttpRouteRuleMatchQueryParameterArrayOutput() HttpRouteRuleMatchQueryParameterArrayOutput

func (HttpRouteRuleMatchQueryParameterArrayOutput) ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterArrayOutput) ToHttpRouteRuleMatchQueryParameterArrayOutputWithContext(ctx context.Context) HttpRouteRuleMatchQueryParameterArrayOutput

type HttpRouteRuleMatchQueryParameterInput added in v6.55.0 

type HttpRouteRuleMatchQueryParameterInput interface {
	pulumi.Input

	ToHttpRouteRuleMatchQueryParameterOutput() HttpRouteRuleMatchQueryParameterOutput
	ToHttpRouteRuleMatchQueryParameterOutputWithContext(context.Context) HttpRouteRuleMatchQueryParameterOutput
}

HttpRouteRuleMatchQueryParameterInput is an input type that accepts HttpRouteRuleMatchQueryParameterArgs and HttpRouteRuleMatchQueryParameterOutput values. You can construct a concrete instance of `HttpRouteRuleMatchQueryParameterInput` via: 

HttpRouteRuleMatchQueryParameterArgs{...}

type HttpRouteRuleMatchQueryParameterOutput added in v6.55.0 

type HttpRouteRuleMatchQueryParameterOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleMatchQueryParameterOutput) ElementType added in v6.55.0 

func (HttpRouteRuleMatchQueryParameterOutput) ElementType() reflect.Type

func (HttpRouteRuleMatchQueryParameterOutput) ExactMatch added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterOutput) ExactMatch() pulumi.StringPtrOutput

The value of the query parameter must exactly match the contents of exactMatch.

func (HttpRouteRuleMatchQueryParameterOutput) PresentMatch added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterOutput) PresentMatch() pulumi.BoolPtrOutput

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

func (HttpRouteRuleMatchQueryParameterOutput) QueryParameter added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterOutput) QueryParameter() pulumi.StringPtrOutput

The name of the query parameter to match.

func (HttpRouteRuleMatchQueryParameterOutput) RegexMatch added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterOutput) RegexMatch() pulumi.StringPtrOutput

The value of the query parameter must match the regular expression specified by regexMatch.For regular expression grammar, please see https://github.com/google/re2/wiki/Syntax

func (HttpRouteRuleMatchQueryParameterOutput) ToHttpRouteRuleMatchQueryParameterOutput added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterOutput) ToHttpRouteRuleMatchQueryParameterOutput() HttpRouteRuleMatchQueryParameterOutput

func (HttpRouteRuleMatchQueryParameterOutput) ToHttpRouteRuleMatchQueryParameterOutputWithContext added in v6.55.0 

func (o HttpRouteRuleMatchQueryParameterOutput) ToHttpRouteRuleMatchQueryParameterOutputWithContext(ctx context.Context) HttpRouteRuleMatchQueryParameterOutput

type HttpRouteRuleOutput added in v6.55.0 

type HttpRouteRuleOutput struct{ *pulumi.OutputState }

func (HttpRouteRuleOutput) Action added in v6.55.0 

func (o HttpRouteRuleOutput) Action() HttpRouteRuleActionPtrOutput

The detailed rule defining how to route matched traffic. Structure is documented below.

func (HttpRouteRuleOutput) ElementType added in v6.55.0 

func (HttpRouteRuleOutput) ElementType() reflect.Type

func (HttpRouteRuleOutput) Matches added in v6.55.0 

func (o HttpRouteRuleOutput) Matches() HttpRouteRuleMatchArrayOutput

A list of matches define conditions used for matching the rule against incoming HTTP requests. Each match is independent, i.e. this rule will be matched if ANY one of the matches is satisfied. If no matches field is specified, this rule will unconditionally match traffic. If a default rule is desired to be configured, add a rule with no matches specified to the end of the rules list. Structure is documented below.

func (HttpRouteRuleOutput) ToHttpRouteRuleOutput added in v6.55.0 

func (o HttpRouteRuleOutput) ToHttpRouteRuleOutput() HttpRouteRuleOutput

func (HttpRouteRuleOutput) ToHttpRouteRuleOutputWithContext added in v6.55.0 

func (o HttpRouteRuleOutput) ToHttpRouteRuleOutputWithContext(ctx context.Context) HttpRouteRuleOutput

type HttpRouteState added in v6.55.0 

type HttpRouteState struct {
	// Time the HttpRoute was created in UTC.
	CreateTime pulumi.StringPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Gateways defines a list of gateways this HttpRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayInput
	// Set of hosts that should match against the HTTP host header to select a HttpRoute to process the request.
	Hostnames pulumi.StringArrayInput
	// Set of label tags associated with the HttpRoute resource.
	Labels pulumi.StringMapInput
	// Meshes defines a list of meshes this HttpRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>.
	// The attached Mesh should be of a type SIDECAR.
	Meshes pulumi.StringArrayInput
	// Name of the HttpRoute resource.
	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
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules HttpRouteRuleArrayInput
	// Server-defined URL of this resource.
	SelfLink pulumi.StringPtrInput
	// Time the HttpRoute was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (HttpRouteState) ElementType added in v6.55.0 

func (HttpRouteState) ElementType() reflect.Type

type Mesh added in v6.54.0 

type Mesh struct {
	pulumi.CustomResourceState

	// Time the Mesh was created in UTC.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Optional. If set to a valid TCP port (1-65535), instructs the SIDECAR proxy to listen on the
	// specified port of localhost (127.0.0.1) address. The SIDECAR proxy will expect all traffic to
	// be redirected to this port regardless of its actual ip:port destination. If unset, a port
	// '15001' is used as the interception port. This will is applicable only for sidecar proxy
	// deployments.
	InterceptionPort pulumi.IntPtrOutput `pulumi:"interceptionPort"`
	// Set of label tags associated with the Mesh resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Short name of the Mesh resource to be created.
	//
	// ***
	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"`
	// Server-defined URL of this resource.
	SelfLink pulumi.StringOutput `pulumi:"selfLink"`
	// Time the Mesh was updated in UTC.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

## Example Usage ### Network Services Mesh 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.NewMesh(ctx, "default", &networkservices.MeshArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description:      pulumi.String("my description"),
			InterceptionPort: pulumi.Int(443),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Network Services Mesh No Port

```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.NewMesh(ctx, "default", &networkservices.MeshArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Mesh can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/mesh:Mesh default projects/{{project}}/locations/global/meshes/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/mesh:Mesh default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/mesh:Mesh default {{name}}

```

func GetMesh added in v6.54.0 

func GetMesh(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *MeshState, opts ...pulumi.ResourceOption) (*Mesh, error)

GetMesh gets an existing Mesh 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 NewMesh added in v6.54.0 

func NewMesh(ctx *pulumi.Context,
	name string, args *MeshArgs, opts ...pulumi.ResourceOption) (*Mesh, error)

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

func (*Mesh) ElementType added in v6.54.0 

func (*Mesh) ElementType() reflect.Type

func (*Mesh) ToMeshOutput added in v6.54.0 

func (i *Mesh) ToMeshOutput() MeshOutput

func (*Mesh) ToMeshOutputWithContext added in v6.54.0 

func (i *Mesh) ToMeshOutputWithContext(ctx context.Context) MeshOutput

type MeshArgs added in v6.54.0 

type MeshArgs struct {
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Optional. If set to a valid TCP port (1-65535), instructs the SIDECAR proxy to listen on the
	// specified port of localhost (127.0.0.1) address. The SIDECAR proxy will expect all traffic to
	// be redirected to this port regardless of its actual ip:port destination. If unset, a port
	// '15001' is used as the interception port. This will is applicable only for sidecar proxy
	// deployments.
	InterceptionPort pulumi.IntPtrInput
	// Set of label tags associated with the Mesh resource.
	Labels pulumi.StringMapInput
	// Short name of the Mesh resource to be created.
	//
	// ***
	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
}

The set of arguments for constructing a Mesh resource.

func (MeshArgs) ElementType added in v6.54.0 

func (MeshArgs) ElementType() reflect.Type

type MeshArray added in v6.54.0 

type MeshArray []MeshInput

func (MeshArray) ElementType added in v6.54.0 

func (MeshArray) ElementType() reflect.Type

func (MeshArray) ToMeshArrayOutput added in v6.54.0 

func (i MeshArray) ToMeshArrayOutput() MeshArrayOutput

func (MeshArray) ToMeshArrayOutputWithContext added in v6.54.0 

func (i MeshArray) ToMeshArrayOutputWithContext(ctx context.Context) MeshArrayOutput

type MeshArrayInput added in v6.54.0 

type MeshArrayInput interface {
	pulumi.Input

	ToMeshArrayOutput() MeshArrayOutput
	ToMeshArrayOutputWithContext(context.Context) MeshArrayOutput
}

MeshArrayInput is an input type that accepts MeshArray and MeshArrayOutput values. You can construct a concrete instance of `MeshArrayInput` via: 

MeshArray{ MeshArgs{...} }

type MeshArrayOutput added in v6.54.0 

type MeshArrayOutput struct{ *pulumi.OutputState }

func (MeshArrayOutput) ElementType added in v6.54.0 

func (MeshArrayOutput) ElementType() reflect.Type

func (MeshArrayOutput) Index added in v6.54.0 

func (o MeshArrayOutput) Index(i pulumi.IntInput) MeshOutput

func (MeshArrayOutput) ToMeshArrayOutput added in v6.54.0 

func (o MeshArrayOutput) ToMeshArrayOutput() MeshArrayOutput

func (MeshArrayOutput) ToMeshArrayOutputWithContext added in v6.54.0 

func (o MeshArrayOutput) ToMeshArrayOutputWithContext(ctx context.Context) MeshArrayOutput

type MeshInput added in v6.54.0 

type MeshInput interface {
	pulumi.Input

	ToMeshOutput() MeshOutput
	ToMeshOutputWithContext(ctx context.Context) MeshOutput
}

type MeshMap added in v6.54.0 

type MeshMap map[string]MeshInput

func (MeshMap) ElementType added in v6.54.0 

func (MeshMap) ElementType() reflect.Type

func (MeshMap) ToMeshMapOutput added in v6.54.0 

func (i MeshMap) ToMeshMapOutput() MeshMapOutput

func (MeshMap) ToMeshMapOutputWithContext added in v6.54.0 

func (i MeshMap) ToMeshMapOutputWithContext(ctx context.Context) MeshMapOutput

type MeshMapInput added in v6.54.0 

type MeshMapInput interface {
	pulumi.Input

	ToMeshMapOutput() MeshMapOutput
	ToMeshMapOutputWithContext(context.Context) MeshMapOutput
}

MeshMapInput is an input type that accepts MeshMap and MeshMapOutput values. You can construct a concrete instance of `MeshMapInput` via: 

MeshMap{ "key": MeshArgs{...} }

type MeshMapOutput added in v6.54.0 

type MeshMapOutput struct{ *pulumi.OutputState }

func (MeshMapOutput) ElementType added in v6.54.0 

func (MeshMapOutput) ElementType() reflect.Type

func (MeshMapOutput) MapIndex added in v6.54.0 

func (o MeshMapOutput) MapIndex(k pulumi.StringInput) MeshOutput

func (MeshMapOutput) ToMeshMapOutput added in v6.54.0 

func (o MeshMapOutput) ToMeshMapOutput() MeshMapOutput

func (MeshMapOutput) ToMeshMapOutputWithContext added in v6.54.0 

func (o MeshMapOutput) ToMeshMapOutputWithContext(ctx context.Context) MeshMapOutput

type MeshOutput added in v6.54.0 

type MeshOutput struct{ *pulumi.OutputState }

func (MeshOutput) CreateTime added in v6.54.0 

func (o MeshOutput) CreateTime() pulumi.StringOutput

Time the Mesh was created in UTC.

func (MeshOutput) Description added in v6.54.0 

func (o MeshOutput) Description() pulumi.StringPtrOutput

A free-text description of the resource. Max length 1024 characters.

func (MeshOutput) ElementType added in v6.54.0 

func (MeshOutput) ElementType() reflect.Type

func (MeshOutput) InterceptionPort added in v6.54.0 

func (o MeshOutput) InterceptionPort() pulumi.IntPtrOutput

Optional. If set to a valid TCP port (1-65535), instructs the SIDECAR proxy to listen on the specified port of localhost (127.0.0.1) address. The SIDECAR proxy will expect all traffic to be redirected to this port regardless of its actual ip:port destination. If unset, a port '15001' is used as the interception port. This will is applicable only for sidecar proxy deployments.

func (MeshOutput) Labels added in v6.54.0 

func (o MeshOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the Mesh resource.

func (MeshOutput) Name added in v6.54.0 

func (o MeshOutput) Name() pulumi.StringOutput

Short name of the Mesh resource to be created.

***

func (MeshOutput) Project added in v6.54.0 

func (o MeshOutput) Project() pulumi.StringOutput

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

func (o MeshOutput) SelfLink() pulumi.StringOutput

Server-defined URL of this resource.

func (MeshOutput) ToMeshOutput added in v6.54.0 

func (o MeshOutput) ToMeshOutput() MeshOutput

func (MeshOutput) ToMeshOutputWithContext added in v6.54.0 

func (o MeshOutput) ToMeshOutputWithContext(ctx context.Context) MeshOutput

func (MeshOutput) UpdateTime added in v6.54.0 

func (o MeshOutput) UpdateTime() pulumi.StringOutput

Time the Mesh was updated in UTC.

type MeshState added in v6.54.0 

type MeshState struct {
	// Time the Mesh was created in UTC.
	CreateTime pulumi.StringPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Optional. If set to a valid TCP port (1-65535), instructs the SIDECAR proxy to listen on the
	// specified port of localhost (127.0.0.1) address. The SIDECAR proxy will expect all traffic to
	// be redirected to this port regardless of its actual ip:port destination. If unset, a port
	// '15001' is used as the interception port. This will is applicable only for sidecar proxy
	// deployments.
	InterceptionPort pulumi.IntPtrInput
	// Set of label tags associated with the Mesh resource.
	Labels pulumi.StringMapInput
	// Short name of the Mesh resource to be created.
	//
	// ***
	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
	// Server-defined URL of this resource.
	SelfLink pulumi.StringPtrInput
	// Time the Mesh was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (MeshState) ElementType added in v6.54.0 

func (MeshState) ElementType() reflect.Type

type ServiceBinding added in v6.56.0 

type ServiceBinding struct {
	pulumi.CustomResourceState

	// Time the ServiceBinding was created in UTC.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Set of label tags associated with the ServiceBinding resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Name of the ServiceBinding resource.
	//
	// ***
	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"`
	// The full Service Directory Service name of the format
	// projects/*/locations/*/namespaces/*/services/*
	Service pulumi.StringOutput `pulumi:"service"`
	// Time the ServiceBinding was updated in UTC.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

## Example Usage ### Network Services Service Binding Basic

```go package main

import ( 

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

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultNamespace, err := servicedirectory.NewNamespace(ctx, "defaultNamespace", &servicedirectory.NamespaceArgs{
			NamespaceId: pulumi.String("my-namespace"),
			Location:    pulumi.String("us-central1"),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		defaultService, err := servicedirectory.NewService(ctx, "defaultService", &servicedirectory.ServiceArgs{
			ServiceId: pulumi.String("my-service"),
			Namespace: defaultNamespace.ID(),
			Metadata: pulumi.StringMap{
				"stage":  pulumi.String("prod"),
				"region": pulumi.String("us-central1"),
			},
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		_, err = networkservices.NewServiceBinding(ctx, "defaultServiceBinding", &networkservices.ServiceBindingArgs{
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
			Description: pulumi.String("my description"),
			Service:     defaultService.ID(),
		}, pulumi.Provider(google_beta))
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

ServiceBinding can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/serviceBinding:ServiceBinding default projects/{{project}}/locations/global/serviceBindings/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/serviceBinding:ServiceBinding default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/serviceBinding:ServiceBinding default {{name}}

```

func GetServiceBinding added in v6.56.0 

func GetServiceBinding(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ServiceBindingState, opts ...pulumi.ResourceOption) (*ServiceBinding, error)

GetServiceBinding gets an existing ServiceBinding 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 NewServiceBinding added in v6.56.0 

func NewServiceBinding(ctx *pulumi.Context,
	name string, args *ServiceBindingArgs, opts ...pulumi.ResourceOption) (*ServiceBinding, error)

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

func (*ServiceBinding) ElementType added in v6.56.0 

func (*ServiceBinding) ElementType() reflect.Type

func (*ServiceBinding) ToServiceBindingOutput added in v6.56.0 

func (i *ServiceBinding) ToServiceBindingOutput() ServiceBindingOutput

func (*ServiceBinding) ToServiceBindingOutputWithContext added in v6.56.0 

func (i *ServiceBinding) ToServiceBindingOutputWithContext(ctx context.Context) ServiceBindingOutput

type ServiceBindingArgs added in v6.56.0 

type ServiceBindingArgs struct {
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Set of label tags associated with the ServiceBinding resource.
	Labels pulumi.StringMapInput
	// Name of the ServiceBinding resource.
	//
	// ***
	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
	// The full Service Directory Service name of the format
	// projects/*/locations/*/namespaces/*/services/*
	Service pulumi.StringInput
}

The set of arguments for constructing a ServiceBinding resource.

func (ServiceBindingArgs) ElementType added in v6.56.0 

func (ServiceBindingArgs) ElementType() reflect.Type

type ServiceBindingArray added in v6.56.0 

type ServiceBindingArray []ServiceBindingInput

func (ServiceBindingArray) ElementType added in v6.56.0 

func (ServiceBindingArray) ElementType() reflect.Type

func (ServiceBindingArray) ToServiceBindingArrayOutput added in v6.56.0 

func (i ServiceBindingArray) ToServiceBindingArrayOutput() ServiceBindingArrayOutput

func (ServiceBindingArray) ToServiceBindingArrayOutputWithContext added in v6.56.0 

func (i ServiceBindingArray) ToServiceBindingArrayOutputWithContext(ctx context.Context) ServiceBindingArrayOutput

type ServiceBindingArrayInput added in v6.56.0 

type ServiceBindingArrayInput interface {
	pulumi.Input

	ToServiceBindingArrayOutput() ServiceBindingArrayOutput
	ToServiceBindingArrayOutputWithContext(context.Context) ServiceBindingArrayOutput
}

ServiceBindingArrayInput is an input type that accepts ServiceBindingArray and ServiceBindingArrayOutput values. You can construct a concrete instance of `ServiceBindingArrayInput` via: 

ServiceBindingArray{ ServiceBindingArgs{...} }

type ServiceBindingArrayOutput added in v6.56.0 

type ServiceBindingArrayOutput struct{ *pulumi.OutputState }

func (ServiceBindingArrayOutput) ElementType added in v6.56.0 

func (ServiceBindingArrayOutput) ElementType() reflect.Type

func (ServiceBindingArrayOutput) Index added in v6.56.0 

func (o ServiceBindingArrayOutput) Index(i pulumi.IntInput) ServiceBindingOutput

func (ServiceBindingArrayOutput) ToServiceBindingArrayOutput added in v6.56.0 

func (o ServiceBindingArrayOutput) ToServiceBindingArrayOutput() ServiceBindingArrayOutput

func (ServiceBindingArrayOutput) ToServiceBindingArrayOutputWithContext added in v6.56.0 

func (o ServiceBindingArrayOutput) ToServiceBindingArrayOutputWithContext(ctx context.Context) ServiceBindingArrayOutput

type ServiceBindingInput added in v6.56.0 

type ServiceBindingInput interface {
	pulumi.Input

	ToServiceBindingOutput() ServiceBindingOutput
	ToServiceBindingOutputWithContext(ctx context.Context) ServiceBindingOutput
}

type ServiceBindingMap added in v6.56.0 

type ServiceBindingMap map[string]ServiceBindingInput

func (ServiceBindingMap) ElementType added in v6.56.0 

func (ServiceBindingMap) ElementType() reflect.Type

func (ServiceBindingMap) ToServiceBindingMapOutput added in v6.56.0 

func (i ServiceBindingMap) ToServiceBindingMapOutput() ServiceBindingMapOutput

func (ServiceBindingMap) ToServiceBindingMapOutputWithContext added in v6.56.0 

func (i ServiceBindingMap) ToServiceBindingMapOutputWithContext(ctx context.Context) ServiceBindingMapOutput

type ServiceBindingMapInput added in v6.56.0 

type ServiceBindingMapInput interface {
	pulumi.Input

	ToServiceBindingMapOutput() ServiceBindingMapOutput
	ToServiceBindingMapOutputWithContext(context.Context) ServiceBindingMapOutput
}

ServiceBindingMapInput is an input type that accepts ServiceBindingMap and ServiceBindingMapOutput values. You can construct a concrete instance of `ServiceBindingMapInput` via: 

ServiceBindingMap{ "key": ServiceBindingArgs{...} }

type ServiceBindingMapOutput added in v6.56.0 

type ServiceBindingMapOutput struct{ *pulumi.OutputState }

func (ServiceBindingMapOutput) ElementType added in v6.56.0 

func (ServiceBindingMapOutput) ElementType() reflect.Type

func (ServiceBindingMapOutput) MapIndex added in v6.56.0 

func (o ServiceBindingMapOutput) MapIndex(k pulumi.StringInput) ServiceBindingOutput

func (ServiceBindingMapOutput) ToServiceBindingMapOutput added in v6.56.0 

func (o ServiceBindingMapOutput) ToServiceBindingMapOutput() ServiceBindingMapOutput

func (ServiceBindingMapOutput) ToServiceBindingMapOutputWithContext added in v6.56.0 

func (o ServiceBindingMapOutput) ToServiceBindingMapOutputWithContext(ctx context.Context) ServiceBindingMapOutput

type ServiceBindingOutput added in v6.56.0 

type ServiceBindingOutput struct{ *pulumi.OutputState }

func (ServiceBindingOutput) CreateTime added in v6.56.0 

func (o ServiceBindingOutput) CreateTime() pulumi.StringOutput

Time the ServiceBinding was created in UTC.

func (ServiceBindingOutput) Description added in v6.56.0 

func (o ServiceBindingOutput) Description() pulumi.StringPtrOutput

A free-text description of the resource. Max length 1024 characters.

func (ServiceBindingOutput) ElementType added in v6.56.0 

func (ServiceBindingOutput) ElementType() reflect.Type

func (ServiceBindingOutput) Labels added in v6.56.0 

func (o ServiceBindingOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the ServiceBinding resource.

func (ServiceBindingOutput) Name added in v6.56.0 

func (o ServiceBindingOutput) Name() pulumi.StringOutput

Name of the ServiceBinding resource.

***

func (ServiceBindingOutput) Project added in v6.56.0 

func (o ServiceBindingOutput) Project() pulumi.StringOutput

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

func (ServiceBindingOutput) Service added in v6.56.0 

func (o ServiceBindingOutput) Service() pulumi.StringOutput

The full Service Directory Service name of the format projects/*/locations/*/namespaces/*/services/*

func (ServiceBindingOutput) ToServiceBindingOutput added in v6.56.0 

func (o ServiceBindingOutput) ToServiceBindingOutput() ServiceBindingOutput

func (ServiceBindingOutput) ToServiceBindingOutputWithContext added in v6.56.0 

func (o ServiceBindingOutput) ToServiceBindingOutputWithContext(ctx context.Context) ServiceBindingOutput

func (ServiceBindingOutput) UpdateTime added in v6.56.0 

func (o ServiceBindingOutput) UpdateTime() pulumi.StringOutput

Time the ServiceBinding was updated in UTC.

type ServiceBindingState added in v6.56.0 

type ServiceBindingState struct {
	// Time the ServiceBinding was created in UTC.
	CreateTime pulumi.StringPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Set of label tags associated with the ServiceBinding resource.
	Labels pulumi.StringMapInput
	// Name of the ServiceBinding resource.
	//
	// ***
	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
	// The full Service Directory Service name of the format
	// projects/*/locations/*/namespaces/*/services/*
	Service pulumi.StringPtrInput
	// Time the ServiceBinding was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (ServiceBindingState) ElementType added in v6.56.0 

func (ServiceBindingState) ElementType() reflect.Type

type TcpRoute added in v6.55.0 

type TcpRoute struct {
	pulumi.CustomResourceState

	// Time the TcpRoute was created in UTC.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Gateways defines a list of gateways this TcpRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayOutput `pulumi:"gateways"`
	// Set of label tags associated with the TcpRoute resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Meshes defines a list of meshes this TcpRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>
	// The attached Mesh should be of a type SIDECAR
	Meshes pulumi.StringArrayOutput `pulumi:"meshes"`
	// Name of the TcpRoute resource.
	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"`
	// Rules that define how traffic is routed and handled. At least one RouteRule must be supplied.
	// If there are multiple rules then the action taken will be the first rule to match.
	// Structure is documented below.
	Rules TcpRouteRuleArrayOutput `pulumi:"rules"`
	// Server-defined URL of this resource.
	SelfLink pulumi.StringOutput `pulumi:"selfLink"`
	// Time the TcpRoute was updated in UTC.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

## Example Usage

## Import

TcpRoute can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/tcpRoute:TcpRoute default projects/{{project}}/locations/global/tcpRoutes/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/tcpRoute:TcpRoute default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/tcpRoute:TcpRoute default {{name}}

```

func GetTcpRoute added in v6.55.0 

func GetTcpRoute(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TcpRouteState, opts ...pulumi.ResourceOption) (*TcpRoute, error)

GetTcpRoute gets an existing TcpRoute 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 NewTcpRoute added in v6.55.0 

func NewTcpRoute(ctx *pulumi.Context,
	name string, args *TcpRouteArgs, opts ...pulumi.ResourceOption) (*TcpRoute, error)

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

func (*TcpRoute) ElementType added in v6.55.0 

func (*TcpRoute) ElementType() reflect.Type

func (*TcpRoute) ToTcpRouteOutput added in v6.55.0 

func (i *TcpRoute) ToTcpRouteOutput() TcpRouteOutput

func (*TcpRoute) ToTcpRouteOutputWithContext added in v6.55.0 

func (i *TcpRoute) ToTcpRouteOutputWithContext(ctx context.Context) TcpRouteOutput

type TcpRouteArgs added in v6.55.0 

type TcpRouteArgs struct {
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Gateways defines a list of gateways this TcpRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayInput
	// Set of label tags associated with the TcpRoute resource.
	Labels pulumi.StringMapInput
	// Meshes defines a list of meshes this TcpRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>
	// The attached Mesh should be of a type SIDECAR
	Meshes pulumi.StringArrayInput
	// Name of the TcpRoute resource.
	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
	// Rules that define how traffic is routed and handled. At least one RouteRule must be supplied.
	// If there are multiple rules then the action taken will be the first rule to match.
	// Structure is documented below.
	Rules TcpRouteRuleArrayInput
}

The set of arguments for constructing a TcpRoute resource.

func (TcpRouteArgs) ElementType added in v6.55.0 

func (TcpRouteArgs) ElementType() reflect.Type

type TcpRouteArray added in v6.55.0 

type TcpRouteArray []TcpRouteInput

func (TcpRouteArray) ElementType added in v6.55.0 

func (TcpRouteArray) ElementType() reflect.Type

func (TcpRouteArray) ToTcpRouteArrayOutput added in v6.55.0 

func (i TcpRouteArray) ToTcpRouteArrayOutput() TcpRouteArrayOutput

func (TcpRouteArray) ToTcpRouteArrayOutputWithContext added in v6.55.0 

func (i TcpRouteArray) ToTcpRouteArrayOutputWithContext(ctx context.Context) TcpRouteArrayOutput

type TcpRouteArrayInput added in v6.55.0 

type TcpRouteArrayInput interface {
	pulumi.Input

	ToTcpRouteArrayOutput() TcpRouteArrayOutput
	ToTcpRouteArrayOutputWithContext(context.Context) TcpRouteArrayOutput
}

TcpRouteArrayInput is an input type that accepts TcpRouteArray and TcpRouteArrayOutput values. You can construct a concrete instance of `TcpRouteArrayInput` via: 

TcpRouteArray{ TcpRouteArgs{...} }

type TcpRouteArrayOutput added in v6.55.0 

type TcpRouteArrayOutput struct{ *pulumi.OutputState }

func (TcpRouteArrayOutput) ElementType added in v6.55.0 

func (TcpRouteArrayOutput) ElementType() reflect.Type

func (TcpRouteArrayOutput) Index added in v6.55.0 

func (o TcpRouteArrayOutput) Index(i pulumi.IntInput) TcpRouteOutput

func (TcpRouteArrayOutput) ToTcpRouteArrayOutput added in v6.55.0 

func (o TcpRouteArrayOutput) ToTcpRouteArrayOutput() TcpRouteArrayOutput

func (TcpRouteArrayOutput) ToTcpRouteArrayOutputWithContext added in v6.55.0 

func (o TcpRouteArrayOutput) ToTcpRouteArrayOutputWithContext(ctx context.Context) TcpRouteArrayOutput

type TcpRouteInput added in v6.55.0 

type TcpRouteInput interface {
	pulumi.Input

	ToTcpRouteOutput() TcpRouteOutput
	ToTcpRouteOutputWithContext(ctx context.Context) TcpRouteOutput
}

type TcpRouteMap added in v6.55.0 

type TcpRouteMap map[string]TcpRouteInput

func (TcpRouteMap) ElementType added in v6.55.0 

func (TcpRouteMap) ElementType() reflect.Type

func (TcpRouteMap) ToTcpRouteMapOutput added in v6.55.0 

func (i TcpRouteMap) ToTcpRouteMapOutput() TcpRouteMapOutput

func (TcpRouteMap) ToTcpRouteMapOutputWithContext added in v6.55.0 

func (i TcpRouteMap) ToTcpRouteMapOutputWithContext(ctx context.Context) TcpRouteMapOutput

type TcpRouteMapInput added in v6.55.0 

type TcpRouteMapInput interface {
	pulumi.Input

	ToTcpRouteMapOutput() TcpRouteMapOutput
	ToTcpRouteMapOutputWithContext(context.Context) TcpRouteMapOutput
}

TcpRouteMapInput is an input type that accepts TcpRouteMap and TcpRouteMapOutput values. You can construct a concrete instance of `TcpRouteMapInput` via: 

TcpRouteMap{ "key": TcpRouteArgs{...} }

type TcpRouteMapOutput added in v6.55.0 

type TcpRouteMapOutput struct{ *pulumi.OutputState }

func (TcpRouteMapOutput) ElementType added in v6.55.0 

func (TcpRouteMapOutput) ElementType() reflect.Type

func (TcpRouteMapOutput) MapIndex added in v6.55.0 

func (o TcpRouteMapOutput) MapIndex(k pulumi.StringInput) TcpRouteOutput

func (TcpRouteMapOutput) ToTcpRouteMapOutput added in v6.55.0 

func (o TcpRouteMapOutput) ToTcpRouteMapOutput() TcpRouteMapOutput

func (TcpRouteMapOutput) ToTcpRouteMapOutputWithContext added in v6.55.0 

func (o TcpRouteMapOutput) ToTcpRouteMapOutputWithContext(ctx context.Context) TcpRouteMapOutput

type TcpRouteOutput added in v6.55.0 

type TcpRouteOutput struct{ *pulumi.OutputState }

func (TcpRouteOutput) CreateTime added in v6.55.0 

func (o TcpRouteOutput) CreateTime() pulumi.StringOutput

Time the TcpRoute was created in UTC.

func (TcpRouteOutput) Description added in v6.55.0 

func (o TcpRouteOutput) Description() pulumi.StringPtrOutput

A free-text description of the resource. Max length 1024 characters.

func (TcpRouteOutput) ElementType added in v6.55.0 

func (TcpRouteOutput) ElementType() reflect.Type

func (TcpRouteOutput) Gateways added in v6.55.0 

func (o TcpRouteOutput) Gateways() pulumi.StringArrayOutput

Gateways defines a list of gateways this TcpRoute is attached to, as one of the routing rules to route the requests served by the gateway. Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>

func (TcpRouteOutput) Labels added in v6.55.0 

func (o TcpRouteOutput) Labels() pulumi.StringMapOutput

Set of label tags associated with the TcpRoute resource.

func (TcpRouteOutput) Meshes added in v6.55.0 

func (o TcpRouteOutput) Meshes() pulumi.StringArrayOutput

Meshes defines a list of meshes this TcpRoute is attached to, as one of the routing rules to route the requests served by the mesh. Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name> The attached Mesh should be of a type SIDECAR

func (TcpRouteOutput) Name added in v6.55.0 

func (o TcpRouteOutput) Name() pulumi.StringOutput

Name of the TcpRoute resource.

func (TcpRouteOutput) Project added in v6.55.0 

func (o TcpRouteOutput) Project() pulumi.StringOutput

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

func (TcpRouteOutput) Rules added in v6.55.0 

func (o TcpRouteOutput) Rules() TcpRouteRuleArrayOutput

Rules that define how traffic is routed and handled. At least one RouteRule must be supplied. If there are multiple rules then the action taken will be the first rule to match. Structure is documented below. 

func (o TcpRouteOutput) SelfLink() pulumi.StringOutput

Server-defined URL of this resource.

func (TcpRouteOutput) ToTcpRouteOutput added in v6.55.0 

func (o TcpRouteOutput) ToTcpRouteOutput() TcpRouteOutput

func (TcpRouteOutput) ToTcpRouteOutputWithContext added in v6.55.0 

func (o TcpRouteOutput) ToTcpRouteOutputWithContext(ctx context.Context) TcpRouteOutput

func (TcpRouteOutput) UpdateTime added in v6.55.0 

func (o TcpRouteOutput) UpdateTime() pulumi.StringOutput

Time the TcpRoute was updated in UTC.

type TcpRouteRule added in v6.55.0 

type TcpRouteRule struct {
	// A detailed rule defining how to route traffic.
	// Structure is documented below.
	Action TcpRouteRuleAction `pulumi:"action"`
	// RouteMatch defines the predicate used to match requests to a given action. Multiple match types are "OR"ed for evaluation.
	// If no routeMatch field is specified, this rule will unconditionally match traffic.
	// Structure is documented below.
	Matches []TcpRouteRuleMatch `pulumi:"matches"`
}

type TcpRouteRuleAction added in v6.55.0 

type TcpRouteRuleAction struct {
	// The destination services to which traffic should be forwarded. At least one destination service is required.
	// Structure is documented below.
	Destinations []TcpRouteRuleActionDestination `pulumi:"destinations"`
	// If true, Router will use the destination IP and port of the original connection as the destination of the request.
	OriginalDestination *bool `pulumi:"originalDestination"`
}

type TcpRouteRuleActionArgs added in v6.55.0 

type TcpRouteRuleActionArgs struct {
	// The destination services to which traffic should be forwarded. At least one destination service is required.
	// Structure is documented below.
	Destinations TcpRouteRuleActionDestinationArrayInput `pulumi:"destinations"`
	// If true, Router will use the destination IP and port of the original connection as the destination of the request.
	OriginalDestination pulumi.BoolPtrInput `pulumi:"originalDestination"`
}

func (TcpRouteRuleActionArgs) ElementType added in v6.55.0 

func (TcpRouteRuleActionArgs) ElementType() reflect.Type

func (TcpRouteRuleActionArgs) ToTcpRouteRuleActionOutput added in v6.55.0 

func (i TcpRouteRuleActionArgs) ToTcpRouteRuleActionOutput() TcpRouteRuleActionOutput

func (TcpRouteRuleActionArgs) ToTcpRouteRuleActionOutputWithContext added in v6.55.0 

func (i TcpRouteRuleActionArgs) ToTcpRouteRuleActionOutputWithContext(ctx context.Context) TcpRouteRuleActionOutput

type TcpRouteRuleActionDestination added in v6.55.0 

type TcpRouteRuleActionDestination struct {
	// The URL of a BackendService to route traffic to.
	ServiceName *string `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
	// If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
	// If weights are specified for any one service name, they need to be specified for all of them.
	// If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
	//
	// ***
	Weight *int `pulumi:"weight"`
}

type TcpRouteRuleActionDestinationArgs added in v6.55.0 

type TcpRouteRuleActionDestinationArgs struct {
	// The URL of a BackendService to route traffic to.
	ServiceName pulumi.StringPtrInput `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports.
	// If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend.
	// If weights are specified for any one service name, they need to be specified for all of them.
	// If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.
	//
	// ***
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

func (TcpRouteRuleActionDestinationArgs) ElementType added in v6.55.0 

func (TcpRouteRuleActionDestinationArgs) ElementType() reflect.Type

func (TcpRouteRuleActionDestinationArgs) ToTcpRouteRuleActionDestinationOutput added in v6.55.0 

func (i TcpRouteRuleActionDestinationArgs) ToTcpRouteRuleActionDestinationOutput() TcpRouteRuleActionDestinationOutput

func (TcpRouteRuleActionDestinationArgs) ToTcpRouteRuleActionDestinationOutputWithContext added in v6.55.0 

func (i TcpRouteRuleActionDestinationArgs) ToTcpRouteRuleActionDestinationOutputWithContext(ctx context.Context) TcpRouteRuleActionDestinationOutput

type TcpRouteRuleActionDestinationArray added in v6.55.0 

type TcpRouteRuleActionDestinationArray []TcpRouteRuleActionDestinationInput

func (TcpRouteRuleActionDestinationArray) ElementType added in v6.55.0 

func (TcpRouteRuleActionDestinationArray) ElementType() reflect.Type

func (TcpRouteRuleActionDestinationArray) ToTcpRouteRuleActionDestinationArrayOutput added in v6.55.0 

func (i TcpRouteRuleActionDestinationArray) ToTcpRouteRuleActionDestinationArrayOutput() TcpRouteRuleActionDestinationArrayOutput

func (TcpRouteRuleActionDestinationArray) ToTcpRouteRuleActionDestinationArrayOutputWithContext added in v6.55.0 

func (i TcpRouteRuleActionDestinationArray) ToTcpRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) TcpRouteRuleActionDestinationArrayOutput

type TcpRouteRuleActionDestinationArrayInput added in v6.55.0 

type TcpRouteRuleActionDestinationArrayInput interface {
	pulumi.Input

	ToTcpRouteRuleActionDestinationArrayOutput() TcpRouteRuleActionDestinationArrayOutput
	ToTcpRouteRuleActionDestinationArrayOutputWithContext(context.Context) TcpRouteRuleActionDestinationArrayOutput
}

TcpRouteRuleActionDestinationArrayInput is an input type that accepts TcpRouteRuleActionDestinationArray and TcpRouteRuleActionDestinationArrayOutput values. You can construct a concrete instance of `TcpRouteRuleActionDestinationArrayInput` via: 

TcpRouteRuleActionDestinationArray{ TcpRouteRuleActionDestinationArgs{...} }

type TcpRouteRuleActionDestinationArrayOutput added in v6.55.0 

type TcpRouteRuleActionDestinationArrayOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleActionDestinationArrayOutput) ElementType added in v6.55.0 

func (TcpRouteRuleActionDestinationArrayOutput) ElementType() reflect.Type

func (TcpRouteRuleActionDestinationArrayOutput) Index added in v6.55.0 

func (o TcpRouteRuleActionDestinationArrayOutput) Index(i pulumi.IntInput) TcpRouteRuleActionDestinationOutput

func (TcpRouteRuleActionDestinationArrayOutput) ToTcpRouteRuleActionDestinationArrayOutput added in v6.55.0 

func (o TcpRouteRuleActionDestinationArrayOutput) ToTcpRouteRuleActionDestinationArrayOutput() TcpRouteRuleActionDestinationArrayOutput

func (TcpRouteRuleActionDestinationArrayOutput) ToTcpRouteRuleActionDestinationArrayOutputWithContext added in v6.55.0 

func (o TcpRouteRuleActionDestinationArrayOutput) ToTcpRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) TcpRouteRuleActionDestinationArrayOutput

type TcpRouteRuleActionDestinationInput added in v6.55.0 

type TcpRouteRuleActionDestinationInput interface {
	pulumi.Input

	ToTcpRouteRuleActionDestinationOutput() TcpRouteRuleActionDestinationOutput
	ToTcpRouteRuleActionDestinationOutputWithContext(context.Context) TcpRouteRuleActionDestinationOutput
}

TcpRouteRuleActionDestinationInput is an input type that accepts TcpRouteRuleActionDestinationArgs and TcpRouteRuleActionDestinationOutput values. You can construct a concrete instance of `TcpRouteRuleActionDestinationInput` via: 

TcpRouteRuleActionDestinationArgs{...}

type TcpRouteRuleActionDestinationOutput added in v6.55.0 

type TcpRouteRuleActionDestinationOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleActionDestinationOutput) ElementType added in v6.55.0 

func (TcpRouteRuleActionDestinationOutput) ElementType() reflect.Type

func (TcpRouteRuleActionDestinationOutput) ServiceName added in v6.55.0 

func (o TcpRouteRuleActionDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (TcpRouteRuleActionDestinationOutput) ToTcpRouteRuleActionDestinationOutput added in v6.55.0 

func (o TcpRouteRuleActionDestinationOutput) ToTcpRouteRuleActionDestinationOutput() TcpRouteRuleActionDestinationOutput

func (TcpRouteRuleActionDestinationOutput) ToTcpRouteRuleActionDestinationOutputWithContext added in v6.55.0 

func (o TcpRouteRuleActionDestinationOutput) ToTcpRouteRuleActionDestinationOutputWithContext(ctx context.Context) TcpRouteRuleActionDestinationOutput

func (TcpRouteRuleActionDestinationOutput) Weight added in v6.55.0 

func (o TcpRouteRuleActionDestinationOutput) Weight() pulumi.IntPtrOutput

Specifies the proportion of requests forwarded to the backend referenced by the serviceName field. This is computed as: weight/Sum(weights in this destination list). For non-zero values, there may be some epsilon from the exact proportion defined here depending on the precision an implementation supports. If only one serviceName is specified and it has a weight greater than 0, 100% of the traffic is forwarded to that backend. If weights are specified for any one service name, they need to be specified for all of them. If weights are unspecified for all services, then, traffic is distributed in equal proportions to all of them.

***

type TcpRouteRuleActionInput added in v6.55.0 

type TcpRouteRuleActionInput interface {
	pulumi.Input

	ToTcpRouteRuleActionOutput() TcpRouteRuleActionOutput
	ToTcpRouteRuleActionOutputWithContext(context.Context) TcpRouteRuleActionOutput
}

TcpRouteRuleActionInput is an input type that accepts TcpRouteRuleActionArgs and TcpRouteRuleActionOutput values. You can construct a concrete instance of `TcpRouteRuleActionInput` via: 

TcpRouteRuleActionArgs{...}

type TcpRouteRuleActionOutput added in v6.55.0 

type TcpRouteRuleActionOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleActionOutput) Destinations added in v6.55.0 

func (o TcpRouteRuleActionOutput) Destinations() TcpRouteRuleActionDestinationArrayOutput

The destination services to which traffic should be forwarded. At least one destination service is required. Structure is documented below.

func (TcpRouteRuleActionOutput) ElementType added in v6.55.0 

func (TcpRouteRuleActionOutput) ElementType() reflect.Type

func (TcpRouteRuleActionOutput) OriginalDestination added in v6.55.0 

func (o TcpRouteRuleActionOutput) OriginalDestination() pulumi.BoolPtrOutput

If true, Router will use the destination IP and port of the original connection as the destination of the request.

func (TcpRouteRuleActionOutput) ToTcpRouteRuleActionOutput added in v6.55.0 

func (o TcpRouteRuleActionOutput) ToTcpRouteRuleActionOutput() TcpRouteRuleActionOutput

func (TcpRouteRuleActionOutput) ToTcpRouteRuleActionOutputWithContext added in v6.55.0 

func (o TcpRouteRuleActionOutput) ToTcpRouteRuleActionOutputWithContext(ctx context.Context) TcpRouteRuleActionOutput

type TcpRouteRuleArgs added in v6.55.0 

type TcpRouteRuleArgs struct {
	// A detailed rule defining how to route traffic.
	// Structure is documented below.
	Action TcpRouteRuleActionInput `pulumi:"action"`
	// RouteMatch defines the predicate used to match requests to a given action. Multiple match types are "OR"ed for evaluation.
	// If no routeMatch field is specified, this rule will unconditionally match traffic.
	// Structure is documented below.
	Matches TcpRouteRuleMatchArrayInput `pulumi:"matches"`
}

func (TcpRouteRuleArgs) ElementType added in v6.55.0 

func (TcpRouteRuleArgs) ElementType() reflect.Type

func (TcpRouteRuleArgs) ToTcpRouteRuleOutput added in v6.55.0 

func (i TcpRouteRuleArgs) ToTcpRouteRuleOutput() TcpRouteRuleOutput

func (TcpRouteRuleArgs) ToTcpRouteRuleOutputWithContext added in v6.55.0 

func (i TcpRouteRuleArgs) ToTcpRouteRuleOutputWithContext(ctx context.Context) TcpRouteRuleOutput

type TcpRouteRuleArray added in v6.55.0 

type TcpRouteRuleArray []TcpRouteRuleInput

func (TcpRouteRuleArray) ElementType added in v6.55.0 

func (TcpRouteRuleArray) ElementType() reflect.Type

func (TcpRouteRuleArray) ToTcpRouteRuleArrayOutput added in v6.55.0 

func (i TcpRouteRuleArray) ToTcpRouteRuleArrayOutput() TcpRouteRuleArrayOutput

func (TcpRouteRuleArray) ToTcpRouteRuleArrayOutputWithContext added in v6.55.0 

func (i TcpRouteRuleArray) ToTcpRouteRuleArrayOutputWithContext(ctx context.Context) TcpRouteRuleArrayOutput

type TcpRouteRuleArrayInput added in v6.55.0 

type TcpRouteRuleArrayInput interface {
	pulumi.Input

	ToTcpRouteRuleArrayOutput() TcpRouteRuleArrayOutput
	ToTcpRouteRuleArrayOutputWithContext(context.Context) TcpRouteRuleArrayOutput
}

TcpRouteRuleArrayInput is an input type that accepts TcpRouteRuleArray and TcpRouteRuleArrayOutput values. You can construct a concrete instance of `TcpRouteRuleArrayInput` via: 

TcpRouteRuleArray{ TcpRouteRuleArgs{...} }

type TcpRouteRuleArrayOutput added in v6.55.0 

type TcpRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleArrayOutput) ElementType added in v6.55.0 

func (TcpRouteRuleArrayOutput) ElementType() reflect.Type

func (TcpRouteRuleArrayOutput) Index added in v6.55.0 

func (o TcpRouteRuleArrayOutput) Index(i pulumi.IntInput) TcpRouteRuleOutput

func (TcpRouteRuleArrayOutput) ToTcpRouteRuleArrayOutput added in v6.55.0 

func (o TcpRouteRuleArrayOutput) ToTcpRouteRuleArrayOutput() TcpRouteRuleArrayOutput

func (TcpRouteRuleArrayOutput) ToTcpRouteRuleArrayOutputWithContext added in v6.55.0 

func (o TcpRouteRuleArrayOutput) ToTcpRouteRuleArrayOutputWithContext(ctx context.Context) TcpRouteRuleArrayOutput

type TcpRouteRuleInput added in v6.55.0 

type TcpRouteRuleInput interface {
	pulumi.Input

	ToTcpRouteRuleOutput() TcpRouteRuleOutput
	ToTcpRouteRuleOutputWithContext(context.Context) TcpRouteRuleOutput
}

TcpRouteRuleInput is an input type that accepts TcpRouteRuleArgs and TcpRouteRuleOutput values. You can construct a concrete instance of `TcpRouteRuleInput` via: 

TcpRouteRuleArgs{...}

type TcpRouteRuleMatch added in v6.55.0 

type TcpRouteRuleMatch struct {
	// Must be specified in the CIDR range format. A CIDR range consists of an IP Address and a prefix length to construct the subnet mask.
	// By default, the prefix length is 32 (i.e. matches a single IP address). Only IPV4 addresses are supported. Examples: "10.0.0.1" - matches against this exact IP address. "10.0.0.0/8" - matches against any IP address within the 10.0.0.0 subnet and 255.255.255.0 mask. "0.0.0.0/0" - matches against any IP address'.
	Address string `pulumi:"address"`
	// Specifies the destination port to match against.
	Port string `pulumi:"port"`
}

type TcpRouteRuleMatchArgs added in v6.55.0 

type TcpRouteRuleMatchArgs struct {
	// Must be specified in the CIDR range format. A CIDR range consists of an IP Address and a prefix length to construct the subnet mask.
	// By default, the prefix length is 32 (i.e. matches a single IP address). Only IPV4 addresses are supported. Examples: "10.0.0.1" - matches against this exact IP address. "10.0.0.0/8" - matches against any IP address within the 10.0.0.0 subnet and 255.255.255.0 mask. "0.0.0.0/0" - matches against any IP address'.
	Address pulumi.StringInput `pulumi:"address"`
	// Specifies the destination port to match against.
	Port pulumi.StringInput `pulumi:"port"`
}

func (TcpRouteRuleMatchArgs) ElementType added in v6.55.0 

func (TcpRouteRuleMatchArgs) ElementType() reflect.Type

func (TcpRouteRuleMatchArgs) ToTcpRouteRuleMatchOutput added in v6.55.0 

func (i TcpRouteRuleMatchArgs) ToTcpRouteRuleMatchOutput() TcpRouteRuleMatchOutput

func (TcpRouteRuleMatchArgs) ToTcpRouteRuleMatchOutputWithContext added in v6.55.0 

func (i TcpRouteRuleMatchArgs) ToTcpRouteRuleMatchOutputWithContext(ctx context.Context) TcpRouteRuleMatchOutput

type TcpRouteRuleMatchArray added in v6.55.0 

type TcpRouteRuleMatchArray []TcpRouteRuleMatchInput

func (TcpRouteRuleMatchArray) ElementType added in v6.55.0 

func (TcpRouteRuleMatchArray) ElementType() reflect.Type

func (TcpRouteRuleMatchArray) ToTcpRouteRuleMatchArrayOutput added in v6.55.0 

func (i TcpRouteRuleMatchArray) ToTcpRouteRuleMatchArrayOutput() TcpRouteRuleMatchArrayOutput

func (TcpRouteRuleMatchArray) ToTcpRouteRuleMatchArrayOutputWithContext added in v6.55.0 

func (i TcpRouteRuleMatchArray) ToTcpRouteRuleMatchArrayOutputWithContext(ctx context.Context) TcpRouteRuleMatchArrayOutput

type TcpRouteRuleMatchArrayInput added in v6.55.0 

type TcpRouteRuleMatchArrayInput interface {
	pulumi.Input

	ToTcpRouteRuleMatchArrayOutput() TcpRouteRuleMatchArrayOutput
	ToTcpRouteRuleMatchArrayOutputWithContext(context.Context) TcpRouteRuleMatchArrayOutput
}

TcpRouteRuleMatchArrayInput is an input type that accepts TcpRouteRuleMatchArray and TcpRouteRuleMatchArrayOutput values. You can construct a concrete instance of `TcpRouteRuleMatchArrayInput` via: 

TcpRouteRuleMatchArray{ TcpRouteRuleMatchArgs{...} }

type TcpRouteRuleMatchArrayOutput added in v6.55.0 

type TcpRouteRuleMatchArrayOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleMatchArrayOutput) ElementType added in v6.55.0 

func (TcpRouteRuleMatchArrayOutput) ElementType() reflect.Type

func (TcpRouteRuleMatchArrayOutput) Index added in v6.55.0 

func (o TcpRouteRuleMatchArrayOutput) Index(i pulumi.IntInput) TcpRouteRuleMatchOutput

func (TcpRouteRuleMatchArrayOutput) ToTcpRouteRuleMatchArrayOutput added in v6.55.0 

func (o TcpRouteRuleMatchArrayOutput) ToTcpRouteRuleMatchArrayOutput() TcpRouteRuleMatchArrayOutput

func (TcpRouteRuleMatchArrayOutput) ToTcpRouteRuleMatchArrayOutputWithContext added in v6.55.0 

func (o TcpRouteRuleMatchArrayOutput) ToTcpRouteRuleMatchArrayOutputWithContext(ctx context.Context) TcpRouteRuleMatchArrayOutput

type TcpRouteRuleMatchInput added in v6.55.0 

type TcpRouteRuleMatchInput interface {
	pulumi.Input

	ToTcpRouteRuleMatchOutput() TcpRouteRuleMatchOutput
	ToTcpRouteRuleMatchOutputWithContext(context.Context) TcpRouteRuleMatchOutput
}

TcpRouteRuleMatchInput is an input type that accepts TcpRouteRuleMatchArgs and TcpRouteRuleMatchOutput values. You can construct a concrete instance of `TcpRouteRuleMatchInput` via: 

TcpRouteRuleMatchArgs{...}

type TcpRouteRuleMatchOutput added in v6.55.0 

type TcpRouteRuleMatchOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleMatchOutput) Address added in v6.55.0 

func (o TcpRouteRuleMatchOutput) Address() pulumi.StringOutput

Must be specified in the CIDR range format. A CIDR range consists of an IP Address and a prefix length to construct the subnet mask. By default, the prefix length is 32 (i.e. matches a single IP address). Only IPV4 addresses are supported. Examples: "10.0.0.1" - matches against this exact IP address. "10.0.0.0/8" - matches against any IP address within the 10.0.0.0 subnet and 255.255.255.0 mask. "0.0.0.0/0" - matches against any IP address'.

func (TcpRouteRuleMatchOutput) ElementType added in v6.55.0 

func (TcpRouteRuleMatchOutput) ElementType() reflect.Type

func (TcpRouteRuleMatchOutput) Port added in v6.55.0 

func (o TcpRouteRuleMatchOutput) Port() pulumi.StringOutput

Specifies the destination port to match against.

func (TcpRouteRuleMatchOutput) ToTcpRouteRuleMatchOutput added in v6.55.0 

func (o TcpRouteRuleMatchOutput) ToTcpRouteRuleMatchOutput() TcpRouteRuleMatchOutput

func (TcpRouteRuleMatchOutput) ToTcpRouteRuleMatchOutputWithContext added in v6.55.0 

func (o TcpRouteRuleMatchOutput) ToTcpRouteRuleMatchOutputWithContext(ctx context.Context) TcpRouteRuleMatchOutput

type TcpRouteRuleOutput added in v6.55.0 

type TcpRouteRuleOutput struct{ *pulumi.OutputState }

func (TcpRouteRuleOutput) Action added in v6.55.0 

func (o TcpRouteRuleOutput) Action() TcpRouteRuleActionOutput

A detailed rule defining how to route traffic. Structure is documented below.

func (TcpRouteRuleOutput) ElementType added in v6.55.0 

func (TcpRouteRuleOutput) ElementType() reflect.Type

func (TcpRouteRuleOutput) Matches added in v6.55.0 

func (o TcpRouteRuleOutput) Matches() TcpRouteRuleMatchArrayOutput

RouteMatch defines the predicate used to match requests to a given action. Multiple match types are "OR"ed for evaluation. If no routeMatch field is specified, this rule will unconditionally match traffic. Structure is documented below.

func (TcpRouteRuleOutput) ToTcpRouteRuleOutput added in v6.55.0 

func (o TcpRouteRuleOutput) ToTcpRouteRuleOutput() TcpRouteRuleOutput

func (TcpRouteRuleOutput) ToTcpRouteRuleOutputWithContext added in v6.55.0 

func (o TcpRouteRuleOutput) ToTcpRouteRuleOutputWithContext(ctx context.Context) TcpRouteRuleOutput

type TcpRouteState added in v6.55.0 

type TcpRouteState struct {
	// Time the TcpRoute was created in UTC.
	CreateTime pulumi.StringPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Gateways defines a list of gateways this TcpRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayInput
	// Set of label tags associated with the TcpRoute resource.
	Labels pulumi.StringMapInput
	// Meshes defines a list of meshes this TcpRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>
	// The attached Mesh should be of a type SIDECAR
	Meshes pulumi.StringArrayInput
	// Name of the TcpRoute resource.
	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
	// Rules that define how traffic is routed and handled. At least one RouteRule must be supplied.
	// If there are multiple rules then the action taken will be the first rule to match.
	// Structure is documented below.
	Rules TcpRouteRuleArrayInput
	// Server-defined URL of this resource.
	SelfLink pulumi.StringPtrInput
	// Time the TcpRoute was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (TcpRouteState) ElementType added in v6.55.0 

func (TcpRouteState) ElementType() reflect.Type

type TlsRoute added in v6.56.0 

type TlsRoute struct {
	pulumi.CustomResourceState

	// Time the TlsRoute was created in UTC.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Gateways defines a list of gateways this TlsRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayOutput `pulumi:"gateways"`
	// Meshes defines a list of meshes this TlsRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>
	// The attached Mesh should be of a type SIDECAR
	Meshes pulumi.StringArrayOutput `pulumi:"meshes"`
	// Name of the TlsRoute resource.
	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"`
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules TlsRouteRuleArrayOutput `pulumi:"rules"`
	// Server-defined URL of this resource.
	SelfLink pulumi.StringOutput `pulumi:"selfLink"`
	// Time the TlsRoute was updated in UTC.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

## Example Usage

## Import

TlsRoute can be imported using any of these accepted formats

```sh 

$ pulumi import gcp:networkservices/tlsRoute:TlsRoute default projects/{{project}}/locations/global/tlsRoutes/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/tlsRoute:TlsRoute default {{project}}/{{name}}

```

```sh 

$ pulumi import gcp:networkservices/tlsRoute:TlsRoute default {{name}}

```

func GetTlsRoute added in v6.56.0 

func GetTlsRoute(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *TlsRouteState, opts ...pulumi.ResourceOption) (*TlsRoute, error)

GetTlsRoute gets an existing TlsRoute 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 NewTlsRoute added in v6.56.0 

func NewTlsRoute(ctx *pulumi.Context,
	name string, args *TlsRouteArgs, opts ...pulumi.ResourceOption) (*TlsRoute, error)

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

func (*TlsRoute) ElementType added in v6.56.0 

func (*TlsRoute) ElementType() reflect.Type

func (*TlsRoute) ToTlsRouteOutput added in v6.56.0 

func (i *TlsRoute) ToTlsRouteOutput() TlsRouteOutput

func (*TlsRoute) ToTlsRouteOutputWithContext added in v6.56.0 

func (i *TlsRoute) ToTlsRouteOutputWithContext(ctx context.Context) TlsRouteOutput

type TlsRouteArgs added in v6.56.0 

type TlsRouteArgs struct {
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Gateways defines a list of gateways this TlsRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayInput
	// Meshes defines a list of meshes this TlsRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>
	// The attached Mesh should be of a type SIDECAR
	Meshes pulumi.StringArrayInput
	// Name of the TlsRoute resource.
	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
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules TlsRouteRuleArrayInput
}

The set of arguments for constructing a TlsRoute resource.

func (TlsRouteArgs) ElementType added in v6.56.0 

func (TlsRouteArgs) ElementType() reflect.Type

type TlsRouteArray added in v6.56.0 

type TlsRouteArray []TlsRouteInput

func (TlsRouteArray) ElementType added in v6.56.0 

func (TlsRouteArray) ElementType() reflect.Type

func (TlsRouteArray) ToTlsRouteArrayOutput added in v6.56.0 

func (i TlsRouteArray) ToTlsRouteArrayOutput() TlsRouteArrayOutput

func (TlsRouteArray) ToTlsRouteArrayOutputWithContext added in v6.56.0 

func (i TlsRouteArray) ToTlsRouteArrayOutputWithContext(ctx context.Context) TlsRouteArrayOutput

type TlsRouteArrayInput added in v6.56.0 

type TlsRouteArrayInput interface {
	pulumi.Input

	ToTlsRouteArrayOutput() TlsRouteArrayOutput
	ToTlsRouteArrayOutputWithContext(context.Context) TlsRouteArrayOutput
}

TlsRouteArrayInput is an input type that accepts TlsRouteArray and TlsRouteArrayOutput values. You can construct a concrete instance of `TlsRouteArrayInput` via: 

TlsRouteArray{ TlsRouteArgs{...} }

type TlsRouteArrayOutput added in v6.56.0 

type TlsRouteArrayOutput struct{ *pulumi.OutputState }

func (TlsRouteArrayOutput) ElementType added in v6.56.0 

func (TlsRouteArrayOutput) ElementType() reflect.Type

func (TlsRouteArrayOutput) Index added in v6.56.0 

func (o TlsRouteArrayOutput) Index(i pulumi.IntInput) TlsRouteOutput

func (TlsRouteArrayOutput) ToTlsRouteArrayOutput added in v6.56.0 

func (o TlsRouteArrayOutput) ToTlsRouteArrayOutput() TlsRouteArrayOutput

func (TlsRouteArrayOutput) ToTlsRouteArrayOutputWithContext added in v6.56.0 

func (o TlsRouteArrayOutput) ToTlsRouteArrayOutputWithContext(ctx context.Context) TlsRouteArrayOutput

type TlsRouteInput added in v6.56.0 

type TlsRouteInput interface {
	pulumi.Input

	ToTlsRouteOutput() TlsRouteOutput
	ToTlsRouteOutputWithContext(ctx context.Context) TlsRouteOutput
}

type TlsRouteMap added in v6.56.0 

type TlsRouteMap map[string]TlsRouteInput

func (TlsRouteMap) ElementType added in v6.56.0 

func (TlsRouteMap) ElementType() reflect.Type

func (TlsRouteMap) ToTlsRouteMapOutput added in v6.56.0 

func (i TlsRouteMap) ToTlsRouteMapOutput() TlsRouteMapOutput

func (TlsRouteMap) ToTlsRouteMapOutputWithContext added in v6.56.0 

func (i TlsRouteMap) ToTlsRouteMapOutputWithContext(ctx context.Context) TlsRouteMapOutput

type TlsRouteMapInput added in v6.56.0 

type TlsRouteMapInput interface {
	pulumi.Input

	ToTlsRouteMapOutput() TlsRouteMapOutput
	ToTlsRouteMapOutputWithContext(context.Context) TlsRouteMapOutput
}

TlsRouteMapInput is an input type that accepts TlsRouteMap and TlsRouteMapOutput values. You can construct a concrete instance of `TlsRouteMapInput` via: 

TlsRouteMap{ "key": TlsRouteArgs{...} }

type TlsRouteMapOutput added in v6.56.0 

type TlsRouteMapOutput struct{ *pulumi.OutputState }

func (TlsRouteMapOutput) ElementType added in v6.56.0 

func (TlsRouteMapOutput) ElementType() reflect.Type

func (TlsRouteMapOutput) MapIndex added in v6.56.0 

func (o TlsRouteMapOutput) MapIndex(k pulumi.StringInput) TlsRouteOutput

func (TlsRouteMapOutput) ToTlsRouteMapOutput added in v6.56.0 

func (o TlsRouteMapOutput) ToTlsRouteMapOutput() TlsRouteMapOutput

func (TlsRouteMapOutput) ToTlsRouteMapOutputWithContext added in v6.56.0 

func (o TlsRouteMapOutput) ToTlsRouteMapOutputWithContext(ctx context.Context) TlsRouteMapOutput

type TlsRouteOutput added in v6.56.0 

type TlsRouteOutput struct{ *pulumi.OutputState }

func (TlsRouteOutput) CreateTime added in v6.56.0 

func (o TlsRouteOutput) CreateTime() pulumi.StringOutput

Time the TlsRoute was created in UTC.

func (TlsRouteOutput) Description added in v6.56.0 

func (o TlsRouteOutput) Description() pulumi.StringPtrOutput

A free-text description of the resource. Max length 1024 characters.

func (TlsRouteOutput) ElementType added in v6.56.0 

func (TlsRouteOutput) ElementType() reflect.Type

func (TlsRouteOutput) Gateways added in v6.56.0 

func (o TlsRouteOutput) Gateways() pulumi.StringArrayOutput

Gateways defines a list of gateways this TlsRoute is attached to, as one of the routing rules to route the requests served by the gateway. Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>

func (TlsRouteOutput) Meshes added in v6.56.0 

func (o TlsRouteOutput) Meshes() pulumi.StringArrayOutput

Meshes defines a list of meshes this TlsRoute is attached to, as one of the routing rules to route the requests served by the mesh. Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name> The attached Mesh should be of a type SIDECAR

func (TlsRouteOutput) Name added in v6.56.0 

func (o TlsRouteOutput) Name() pulumi.StringOutput

Name of the TlsRoute resource.

func (TlsRouteOutput) Project added in v6.56.0 

func (o TlsRouteOutput) Project() pulumi.StringOutput

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

func (TlsRouteOutput) Rules added in v6.56.0 

func (o TlsRouteOutput) Rules() TlsRouteRuleArrayOutput

Rules that define how traffic is routed and handled. Structure is documented below. 

func (o TlsRouteOutput) SelfLink() pulumi.StringOutput

Server-defined URL of this resource.

func (TlsRouteOutput) ToTlsRouteOutput added in v6.56.0 

func (o TlsRouteOutput) ToTlsRouteOutput() TlsRouteOutput

func (TlsRouteOutput) ToTlsRouteOutputWithContext added in v6.56.0 

func (o TlsRouteOutput) ToTlsRouteOutputWithContext(ctx context.Context) TlsRouteOutput

func (TlsRouteOutput) UpdateTime added in v6.56.0 

func (o TlsRouteOutput) UpdateTime() pulumi.StringOutput

Time the TlsRoute was updated in UTC.

type TlsRouteRule added in v6.56.0 

type TlsRouteRule struct {
	// Required. A detailed rule defining how to route traffic.
	// Structure is documented below.
	Action TlsRouteRuleAction `pulumi:"action"`
	// Matches define the predicate used to match requests to a given action.
	// Structure is documented below.
	Matches []TlsRouteRuleMatch `pulumi:"matches"`
}

type TlsRouteRuleAction added in v6.56.0 

type TlsRouteRuleAction struct {
	// The destination to which traffic should be forwarded.
	// Structure is documented below.
	Destinations []TlsRouteRuleActionDestination `pulumi:"destinations"`
}

type TlsRouteRuleActionArgs added in v6.56.0 

type TlsRouteRuleActionArgs struct {
	// The destination to which traffic should be forwarded.
	// Structure is documented below.
	Destinations TlsRouteRuleActionDestinationArrayInput `pulumi:"destinations"`
}

func (TlsRouteRuleActionArgs) ElementType added in v6.56.0 

func (TlsRouteRuleActionArgs) ElementType() reflect.Type

func (TlsRouteRuleActionArgs) ToTlsRouteRuleActionOutput added in v6.56.0 

func (i TlsRouteRuleActionArgs) ToTlsRouteRuleActionOutput() TlsRouteRuleActionOutput

func (TlsRouteRuleActionArgs) ToTlsRouteRuleActionOutputWithContext added in v6.56.0 

func (i TlsRouteRuleActionArgs) ToTlsRouteRuleActionOutputWithContext(ctx context.Context) TlsRouteRuleActionOutput

type TlsRouteRuleActionDestination added in v6.56.0 

type TlsRouteRuleActionDestination struct {
	// The URL of a BackendService to route traffic to.
	ServiceName *string `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
	//
	// ***
	Weight *int `pulumi:"weight"`
}

type TlsRouteRuleActionDestinationArgs added in v6.56.0 

type TlsRouteRuleActionDestinationArgs struct {
	// The URL of a BackendService to route traffic to.
	ServiceName pulumi.StringPtrInput `pulumi:"serviceName"`
	// Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.
	//
	// ***
	Weight pulumi.IntPtrInput `pulumi:"weight"`
}

func (TlsRouteRuleActionDestinationArgs) ElementType added in v6.56.0 

func (TlsRouteRuleActionDestinationArgs) ElementType() reflect.Type

func (TlsRouteRuleActionDestinationArgs) ToTlsRouteRuleActionDestinationOutput added in v6.56.0 

func (i TlsRouteRuleActionDestinationArgs) ToTlsRouteRuleActionDestinationOutput() TlsRouteRuleActionDestinationOutput

func (TlsRouteRuleActionDestinationArgs) ToTlsRouteRuleActionDestinationOutputWithContext added in v6.56.0 

func (i TlsRouteRuleActionDestinationArgs) ToTlsRouteRuleActionDestinationOutputWithContext(ctx context.Context) TlsRouteRuleActionDestinationOutput

type TlsRouteRuleActionDestinationArray added in v6.56.0 

type TlsRouteRuleActionDestinationArray []TlsRouteRuleActionDestinationInput

func (TlsRouteRuleActionDestinationArray) ElementType added in v6.56.0 

func (TlsRouteRuleActionDestinationArray) ElementType() reflect.Type

func (TlsRouteRuleActionDestinationArray) ToTlsRouteRuleActionDestinationArrayOutput added in v6.56.0 

func (i TlsRouteRuleActionDestinationArray) ToTlsRouteRuleActionDestinationArrayOutput() TlsRouteRuleActionDestinationArrayOutput

func (TlsRouteRuleActionDestinationArray) ToTlsRouteRuleActionDestinationArrayOutputWithContext added in v6.56.0 

func (i TlsRouteRuleActionDestinationArray) ToTlsRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) TlsRouteRuleActionDestinationArrayOutput

type TlsRouteRuleActionDestinationArrayInput added in v6.56.0 

type TlsRouteRuleActionDestinationArrayInput interface {
	pulumi.Input

	ToTlsRouteRuleActionDestinationArrayOutput() TlsRouteRuleActionDestinationArrayOutput
	ToTlsRouteRuleActionDestinationArrayOutputWithContext(context.Context) TlsRouteRuleActionDestinationArrayOutput
}

TlsRouteRuleActionDestinationArrayInput is an input type that accepts TlsRouteRuleActionDestinationArray and TlsRouteRuleActionDestinationArrayOutput values. You can construct a concrete instance of `TlsRouteRuleActionDestinationArrayInput` via: 

TlsRouteRuleActionDestinationArray{ TlsRouteRuleActionDestinationArgs{...} }

type TlsRouteRuleActionDestinationArrayOutput added in v6.56.0 

type TlsRouteRuleActionDestinationArrayOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleActionDestinationArrayOutput) ElementType added in v6.56.0 

func (TlsRouteRuleActionDestinationArrayOutput) ElementType() reflect.Type

func (TlsRouteRuleActionDestinationArrayOutput) Index added in v6.56.0 

func (o TlsRouteRuleActionDestinationArrayOutput) Index(i pulumi.IntInput) TlsRouteRuleActionDestinationOutput

func (TlsRouteRuleActionDestinationArrayOutput) ToTlsRouteRuleActionDestinationArrayOutput added in v6.56.0 

func (o TlsRouteRuleActionDestinationArrayOutput) ToTlsRouteRuleActionDestinationArrayOutput() TlsRouteRuleActionDestinationArrayOutput

func (TlsRouteRuleActionDestinationArrayOutput) ToTlsRouteRuleActionDestinationArrayOutputWithContext added in v6.56.0 

func (o TlsRouteRuleActionDestinationArrayOutput) ToTlsRouteRuleActionDestinationArrayOutputWithContext(ctx context.Context) TlsRouteRuleActionDestinationArrayOutput

type TlsRouteRuleActionDestinationInput added in v6.56.0 

type TlsRouteRuleActionDestinationInput interface {
	pulumi.Input

	ToTlsRouteRuleActionDestinationOutput() TlsRouteRuleActionDestinationOutput
	ToTlsRouteRuleActionDestinationOutputWithContext(context.Context) TlsRouteRuleActionDestinationOutput
}

TlsRouteRuleActionDestinationInput is an input type that accepts TlsRouteRuleActionDestinationArgs and TlsRouteRuleActionDestinationOutput values. You can construct a concrete instance of `TlsRouteRuleActionDestinationInput` via: 

TlsRouteRuleActionDestinationArgs{...}

type TlsRouteRuleActionDestinationOutput added in v6.56.0 

type TlsRouteRuleActionDestinationOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleActionDestinationOutput) ElementType added in v6.56.0 

func (TlsRouteRuleActionDestinationOutput) ElementType() reflect.Type

func (TlsRouteRuleActionDestinationOutput) ServiceName added in v6.56.0 

func (o TlsRouteRuleActionDestinationOutput) ServiceName() pulumi.StringPtrOutput

The URL of a BackendService to route traffic to.

func (TlsRouteRuleActionDestinationOutput) ToTlsRouteRuleActionDestinationOutput added in v6.56.0 

func (o TlsRouteRuleActionDestinationOutput) ToTlsRouteRuleActionDestinationOutput() TlsRouteRuleActionDestinationOutput

func (TlsRouteRuleActionDestinationOutput) ToTlsRouteRuleActionDestinationOutputWithContext added in v6.56.0 

func (o TlsRouteRuleActionDestinationOutput) ToTlsRouteRuleActionDestinationOutputWithContext(ctx context.Context) TlsRouteRuleActionDestinationOutput

func (TlsRouteRuleActionDestinationOutput) Weight added in v6.56.0 

func (o TlsRouteRuleActionDestinationOutput) Weight() pulumi.IntPtrOutput

Specifies the proportion of requests forwarded to the backend referenced by the serviceName field.

***

type TlsRouteRuleActionInput added in v6.56.0 

type TlsRouteRuleActionInput interface {
	pulumi.Input

	ToTlsRouteRuleActionOutput() TlsRouteRuleActionOutput
	ToTlsRouteRuleActionOutputWithContext(context.Context) TlsRouteRuleActionOutput
}

TlsRouteRuleActionInput is an input type that accepts TlsRouteRuleActionArgs and TlsRouteRuleActionOutput values. You can construct a concrete instance of `TlsRouteRuleActionInput` via: 

TlsRouteRuleActionArgs{...}

type TlsRouteRuleActionOutput added in v6.56.0 

type TlsRouteRuleActionOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleActionOutput) Destinations added in v6.56.0 

func (o TlsRouteRuleActionOutput) Destinations() TlsRouteRuleActionDestinationArrayOutput

The destination to which traffic should be forwarded. Structure is documented below.

func (TlsRouteRuleActionOutput) ElementType added in v6.56.0 

func (TlsRouteRuleActionOutput) ElementType() reflect.Type

func (TlsRouteRuleActionOutput) ToTlsRouteRuleActionOutput added in v6.56.0 

func (o TlsRouteRuleActionOutput) ToTlsRouteRuleActionOutput() TlsRouteRuleActionOutput

func (TlsRouteRuleActionOutput) ToTlsRouteRuleActionOutputWithContext added in v6.56.0 

func (o TlsRouteRuleActionOutput) ToTlsRouteRuleActionOutputWithContext(ctx context.Context) TlsRouteRuleActionOutput

type TlsRouteRuleArgs added in v6.56.0 

type TlsRouteRuleArgs struct {
	// Required. A detailed rule defining how to route traffic.
	// Structure is documented below.
	Action TlsRouteRuleActionInput `pulumi:"action"`
	// Matches define the predicate used to match requests to a given action.
	// Structure is documented below.
	Matches TlsRouteRuleMatchArrayInput `pulumi:"matches"`
}

func (TlsRouteRuleArgs) ElementType added in v6.56.0 

func (TlsRouteRuleArgs) ElementType() reflect.Type

func (TlsRouteRuleArgs) ToTlsRouteRuleOutput added in v6.56.0 

func (i TlsRouteRuleArgs) ToTlsRouteRuleOutput() TlsRouteRuleOutput

func (TlsRouteRuleArgs) ToTlsRouteRuleOutputWithContext added in v6.56.0 

func (i TlsRouteRuleArgs) ToTlsRouteRuleOutputWithContext(ctx context.Context) TlsRouteRuleOutput

type TlsRouteRuleArray added in v6.56.0 

type TlsRouteRuleArray []TlsRouteRuleInput

func (TlsRouteRuleArray) ElementType added in v6.56.0 

func (TlsRouteRuleArray) ElementType() reflect.Type

func (TlsRouteRuleArray) ToTlsRouteRuleArrayOutput added in v6.56.0 

func (i TlsRouteRuleArray) ToTlsRouteRuleArrayOutput() TlsRouteRuleArrayOutput

func (TlsRouteRuleArray) ToTlsRouteRuleArrayOutputWithContext added in v6.56.0 

func (i TlsRouteRuleArray) ToTlsRouteRuleArrayOutputWithContext(ctx context.Context) TlsRouteRuleArrayOutput

type TlsRouteRuleArrayInput added in v6.56.0 

type TlsRouteRuleArrayInput interface {
	pulumi.Input

	ToTlsRouteRuleArrayOutput() TlsRouteRuleArrayOutput
	ToTlsRouteRuleArrayOutputWithContext(context.Context) TlsRouteRuleArrayOutput
}

TlsRouteRuleArrayInput is an input type that accepts TlsRouteRuleArray and TlsRouteRuleArrayOutput values. You can construct a concrete instance of `TlsRouteRuleArrayInput` via: 

TlsRouteRuleArray{ TlsRouteRuleArgs{...} }

type TlsRouteRuleArrayOutput added in v6.56.0 

type TlsRouteRuleArrayOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleArrayOutput) ElementType added in v6.56.0 

func (TlsRouteRuleArrayOutput) ElementType() reflect.Type

func (TlsRouteRuleArrayOutput) Index added in v6.56.0 

func (o TlsRouteRuleArrayOutput) Index(i pulumi.IntInput) TlsRouteRuleOutput

func (TlsRouteRuleArrayOutput) ToTlsRouteRuleArrayOutput added in v6.56.0 

func (o TlsRouteRuleArrayOutput) ToTlsRouteRuleArrayOutput() TlsRouteRuleArrayOutput

func (TlsRouteRuleArrayOutput) ToTlsRouteRuleArrayOutputWithContext added in v6.56.0 

func (o TlsRouteRuleArrayOutput) ToTlsRouteRuleArrayOutputWithContext(ctx context.Context) TlsRouteRuleArrayOutput

type TlsRouteRuleInput added in v6.56.0 

type TlsRouteRuleInput interface {
	pulumi.Input

	ToTlsRouteRuleOutput() TlsRouteRuleOutput
	ToTlsRouteRuleOutputWithContext(context.Context) TlsRouteRuleOutput
}

TlsRouteRuleInput is an input type that accepts TlsRouteRuleArgs and TlsRouteRuleOutput values. You can construct a concrete instance of `TlsRouteRuleInput` via: 

TlsRouteRuleArgs{...}

type TlsRouteRuleMatch added in v6.56.0 

type TlsRouteRuleMatch struct {
	// ALPN (Application-Layer Protocol Negotiation) to match against. Examples: "http/1.1", "h2". At least one of sniHost and alpn is required. Up to 5 alpns across all matches can be set.
	Alpns []string `pulumi:"alpns"`
	// SNI (server name indicator) to match against. SNI will be matched against all wildcard domains, i.e. www.example.com will be first matched against www.example.com, then *.example.com, then *.com.
	// Partial wildcards are not supported, and values like *w.example.com are invalid. At least one of sniHost and alpn is required. Up to 5 sni hosts across all matches can be set.
	SniHosts []string `pulumi:"sniHosts"`
}

type TlsRouteRuleMatchArgs added in v6.56.0 

type TlsRouteRuleMatchArgs struct {
	// ALPN (Application-Layer Protocol Negotiation) to match against. Examples: "http/1.1", "h2". At least one of sniHost and alpn is required. Up to 5 alpns across all matches can be set.
	Alpns pulumi.StringArrayInput `pulumi:"alpns"`
	// SNI (server name indicator) to match against. SNI will be matched against all wildcard domains, i.e. www.example.com will be first matched against www.example.com, then *.example.com, then *.com.
	// Partial wildcards are not supported, and values like *w.example.com are invalid. At least one of sniHost and alpn is required. Up to 5 sni hosts across all matches can be set.
	SniHosts pulumi.StringArrayInput `pulumi:"sniHosts"`
}

func (TlsRouteRuleMatchArgs) ElementType added in v6.56.0 

func (TlsRouteRuleMatchArgs) ElementType() reflect.Type

func (TlsRouteRuleMatchArgs) ToTlsRouteRuleMatchOutput added in v6.56.0 

func (i TlsRouteRuleMatchArgs) ToTlsRouteRuleMatchOutput() TlsRouteRuleMatchOutput

func (TlsRouteRuleMatchArgs) ToTlsRouteRuleMatchOutputWithContext added in v6.56.0 

func (i TlsRouteRuleMatchArgs) ToTlsRouteRuleMatchOutputWithContext(ctx context.Context) TlsRouteRuleMatchOutput

type TlsRouteRuleMatchArray added in v6.56.0 

type TlsRouteRuleMatchArray []TlsRouteRuleMatchInput

func (TlsRouteRuleMatchArray) ElementType added in v6.56.0 

func (TlsRouteRuleMatchArray) ElementType() reflect.Type

func (TlsRouteRuleMatchArray) ToTlsRouteRuleMatchArrayOutput added in v6.56.0 

func (i TlsRouteRuleMatchArray) ToTlsRouteRuleMatchArrayOutput() TlsRouteRuleMatchArrayOutput

func (TlsRouteRuleMatchArray) ToTlsRouteRuleMatchArrayOutputWithContext added in v6.56.0 

func (i TlsRouteRuleMatchArray) ToTlsRouteRuleMatchArrayOutputWithContext(ctx context.Context) TlsRouteRuleMatchArrayOutput

type TlsRouteRuleMatchArrayInput added in v6.56.0 

type TlsRouteRuleMatchArrayInput interface {
	pulumi.Input

	ToTlsRouteRuleMatchArrayOutput() TlsRouteRuleMatchArrayOutput
	ToTlsRouteRuleMatchArrayOutputWithContext(context.Context) TlsRouteRuleMatchArrayOutput
}

TlsRouteRuleMatchArrayInput is an input type that accepts TlsRouteRuleMatchArray and TlsRouteRuleMatchArrayOutput values. You can construct a concrete instance of `TlsRouteRuleMatchArrayInput` via: 

TlsRouteRuleMatchArray{ TlsRouteRuleMatchArgs{...} }

type TlsRouteRuleMatchArrayOutput added in v6.56.0 

type TlsRouteRuleMatchArrayOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleMatchArrayOutput) ElementType added in v6.56.0 

func (TlsRouteRuleMatchArrayOutput) ElementType() reflect.Type

func (TlsRouteRuleMatchArrayOutput) Index added in v6.56.0 

func (o TlsRouteRuleMatchArrayOutput) Index(i pulumi.IntInput) TlsRouteRuleMatchOutput

func (TlsRouteRuleMatchArrayOutput) ToTlsRouteRuleMatchArrayOutput added in v6.56.0 

func (o TlsRouteRuleMatchArrayOutput) ToTlsRouteRuleMatchArrayOutput() TlsRouteRuleMatchArrayOutput

func (TlsRouteRuleMatchArrayOutput) ToTlsRouteRuleMatchArrayOutputWithContext added in v6.56.0 

func (o TlsRouteRuleMatchArrayOutput) ToTlsRouteRuleMatchArrayOutputWithContext(ctx context.Context) TlsRouteRuleMatchArrayOutput

type TlsRouteRuleMatchInput added in v6.56.0 

type TlsRouteRuleMatchInput interface {
	pulumi.Input

	ToTlsRouteRuleMatchOutput() TlsRouteRuleMatchOutput
	ToTlsRouteRuleMatchOutputWithContext(context.Context) TlsRouteRuleMatchOutput
}

TlsRouteRuleMatchInput is an input type that accepts TlsRouteRuleMatchArgs and TlsRouteRuleMatchOutput values. You can construct a concrete instance of `TlsRouteRuleMatchInput` via: 

TlsRouteRuleMatchArgs{...}

type TlsRouteRuleMatchOutput added in v6.56.0 

type TlsRouteRuleMatchOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleMatchOutput) Alpns added in v6.56.0 

func (o TlsRouteRuleMatchOutput) Alpns() pulumi.StringArrayOutput

ALPN (Application-Layer Protocol Negotiation) to match against. Examples: "http/1.1", "h2". At least one of sniHost and alpn is required. Up to 5 alpns across all matches can be set.

func (TlsRouteRuleMatchOutput) ElementType added in v6.56.0 

func (TlsRouteRuleMatchOutput) ElementType() reflect.Type

func (TlsRouteRuleMatchOutput) SniHosts added in v6.56.0 

func (o TlsRouteRuleMatchOutput) SniHosts() pulumi.StringArrayOutput

SNI (server name indicator) to match against. SNI will be matched against all wildcard domains, i.e. www.example.com will be first matched against www.example.com, then *.example.com, then *.com. Partial wildcards are not supported, and values like *w.example.com are invalid. At least one of sniHost and alpn is required. Up to 5 sni hosts across all matches can be set.

func (TlsRouteRuleMatchOutput) ToTlsRouteRuleMatchOutput added in v6.56.0 

func (o TlsRouteRuleMatchOutput) ToTlsRouteRuleMatchOutput() TlsRouteRuleMatchOutput

func (TlsRouteRuleMatchOutput) ToTlsRouteRuleMatchOutputWithContext added in v6.56.0 

func (o TlsRouteRuleMatchOutput) ToTlsRouteRuleMatchOutputWithContext(ctx context.Context) TlsRouteRuleMatchOutput

type TlsRouteRuleOutput added in v6.56.0 

type TlsRouteRuleOutput struct{ *pulumi.OutputState }

func (TlsRouteRuleOutput) Action added in v6.56.0 

func (o TlsRouteRuleOutput) Action() TlsRouteRuleActionOutput

Required. A detailed rule defining how to route traffic. Structure is documented below.

func (TlsRouteRuleOutput) ElementType added in v6.56.0 

func (TlsRouteRuleOutput) ElementType() reflect.Type

func (TlsRouteRuleOutput) Matches added in v6.56.0 

func (o TlsRouteRuleOutput) Matches() TlsRouteRuleMatchArrayOutput

Matches define the predicate used to match requests to a given action. Structure is documented below.

func (TlsRouteRuleOutput) ToTlsRouteRuleOutput added in v6.56.0 

func (o TlsRouteRuleOutput) ToTlsRouteRuleOutput() TlsRouteRuleOutput

func (TlsRouteRuleOutput) ToTlsRouteRuleOutputWithContext added in v6.56.0 

func (o TlsRouteRuleOutput) ToTlsRouteRuleOutputWithContext(ctx context.Context) TlsRouteRuleOutput

type TlsRouteState added in v6.56.0 

type TlsRouteState struct {
	// Time the TlsRoute was created in UTC.
	CreateTime pulumi.StringPtrInput
	// A free-text description of the resource. Max length 1024 characters.
	Description pulumi.StringPtrInput
	// Gateways defines a list of gateways this TlsRoute is attached to, as one of the routing rules to route the requests served by the gateway.
	// Each gateway reference should match the pattern: projects/*/locations/global/gateways/<gateway_name>
	Gateways pulumi.StringArrayInput
	// Meshes defines a list of meshes this TlsRoute is attached to, as one of the routing rules to route the requests served by the mesh.
	// Each mesh reference should match the pattern: projects/*/locations/global/meshes/<mesh_name>
	// The attached Mesh should be of a type SIDECAR
	Meshes pulumi.StringArrayInput
	// Name of the TlsRoute resource.
	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
	// Rules that define how traffic is routed and handled.
	// Structure is documented below.
	Rules TlsRouteRuleArrayInput
	// Server-defined URL of this resource.
	SelfLink pulumi.StringPtrInput
	// Time the TlsRoute was updated in UTC.
	UpdateTime pulumi.StringPtrInput
}

func (TlsRouteState) ElementType added in v6.56.0 

func (TlsRouteState) 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.